// Generated by the protocol buffer compiler. DO NOT EDIT! // source: protobuf/pg_query.proto #ifndef GOOGLE_PROTOBUF_INCLUDED_protobuf_2fpg_5fquery_2eproto #define GOOGLE_PROTOBUF_INCLUDED_protobuf_2fpg_5fquery_2eproto #include #include #include #if PROTOBUF_VERSION < 3021000 #error This file was generated by a newer version of protoc which is #error incompatible with your Protocol Buffer headers. Please update #error your headers. #endif #if 3021009 < PROTOBUF_MIN_PROTOC_VERSION #error This file was generated by an older version of protoc which is #error incompatible with your Protocol Buffer headers. Please #error regenerate this file with a newer version of protoc. #endif #include #include #include #include #include #include #include #include #include #include // IWYU pragma: export #include // IWYU pragma: export #include #include // @@protoc_insertion_point(includes) #include #define PROTOBUF_INTERNAL_EXPORT_protobuf_2fpg_5fquery_2eproto PROTOBUF_NAMESPACE_OPEN namespace internal { class AnyMetadata; } // namespace internal PROTOBUF_NAMESPACE_CLOSE // Internal implementation detail -- do not use these members. struct TableStruct_protobuf_2fpg_5fquery_2eproto { static const uint32_t offsets[]; }; extern const ::PROTOBUF_NAMESPACE_ID::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 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 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 PROTOBUF_NAMESPACE_OPEN template<> ::pg_query::A_ArrayExpr* Arena::CreateMaybeMessage<::pg_query::A_ArrayExpr>(Arena*); template<> ::pg_query::A_Const* Arena::CreateMaybeMessage<::pg_query::A_Const>(Arena*); template<> ::pg_query::A_Expr* Arena::CreateMaybeMessage<::pg_query::A_Expr>(Arena*); template<> ::pg_query::A_Indices* Arena::CreateMaybeMessage<::pg_query::A_Indices>(Arena*); template<> ::pg_query::A_Indirection* Arena::CreateMaybeMessage<::pg_query::A_Indirection>(Arena*); template<> ::pg_query::A_Star* Arena::CreateMaybeMessage<::pg_query::A_Star>(Arena*); template<> ::pg_query::AccessPriv* Arena::CreateMaybeMessage<::pg_query::AccessPriv>(Arena*); template<> ::pg_query::Aggref* Arena::CreateMaybeMessage<::pg_query::Aggref>(Arena*); template<> ::pg_query::Alias* Arena::CreateMaybeMessage<::pg_query::Alias>(Arena*); template<> ::pg_query::AlterCollationStmt* Arena::CreateMaybeMessage<::pg_query::AlterCollationStmt>(Arena*); template<> ::pg_query::AlterDatabaseRefreshCollStmt* Arena::CreateMaybeMessage<::pg_query::AlterDatabaseRefreshCollStmt>(Arena*); template<> ::pg_query::AlterDatabaseSetStmt* Arena::CreateMaybeMessage<::pg_query::AlterDatabaseSetStmt>(Arena*); template<> ::pg_query::AlterDatabaseStmt* Arena::CreateMaybeMessage<::pg_query::AlterDatabaseStmt>(Arena*); template<> ::pg_query::AlterDefaultPrivilegesStmt* Arena::CreateMaybeMessage<::pg_query::AlterDefaultPrivilegesStmt>(Arena*); template<> ::pg_query::AlterDomainStmt* Arena::CreateMaybeMessage<::pg_query::AlterDomainStmt>(Arena*); template<> ::pg_query::AlterEnumStmt* Arena::CreateMaybeMessage<::pg_query::AlterEnumStmt>(Arena*); template<> ::pg_query::AlterEventTrigStmt* Arena::CreateMaybeMessage<::pg_query::AlterEventTrigStmt>(Arena*); template<> ::pg_query::AlterExtensionContentsStmt* Arena::CreateMaybeMessage<::pg_query::AlterExtensionContentsStmt>(Arena*); template<> ::pg_query::AlterExtensionStmt* Arena::CreateMaybeMessage<::pg_query::AlterExtensionStmt>(Arena*); template<> ::pg_query::AlterFdwStmt* Arena::CreateMaybeMessage<::pg_query::AlterFdwStmt>(Arena*); template<> ::pg_query::AlterForeignServerStmt* Arena::CreateMaybeMessage<::pg_query::AlterForeignServerStmt>(Arena*); template<> ::pg_query::AlterFunctionStmt* Arena::CreateMaybeMessage<::pg_query::AlterFunctionStmt>(Arena*); template<> ::pg_query::AlterObjectDependsStmt* Arena::CreateMaybeMessage<::pg_query::AlterObjectDependsStmt>(Arena*); template<> ::pg_query::AlterObjectSchemaStmt* Arena::CreateMaybeMessage<::pg_query::AlterObjectSchemaStmt>(Arena*); template<> ::pg_query::AlterOpFamilyStmt* Arena::CreateMaybeMessage<::pg_query::AlterOpFamilyStmt>(Arena*); template<> ::pg_query::AlterOperatorStmt* Arena::CreateMaybeMessage<::pg_query::AlterOperatorStmt>(Arena*); template<> ::pg_query::AlterOwnerStmt* Arena::CreateMaybeMessage<::pg_query::AlterOwnerStmt>(Arena*); template<> ::pg_query::AlterPolicyStmt* Arena::CreateMaybeMessage<::pg_query::AlterPolicyStmt>(Arena*); template<> ::pg_query::AlterPublicationStmt* Arena::CreateMaybeMessage<::pg_query::AlterPublicationStmt>(Arena*); template<> ::pg_query::AlterRoleSetStmt* Arena::CreateMaybeMessage<::pg_query::AlterRoleSetStmt>(Arena*); template<> ::pg_query::AlterRoleStmt* Arena::CreateMaybeMessage<::pg_query::AlterRoleStmt>(Arena*); template<> ::pg_query::AlterSeqStmt* Arena::CreateMaybeMessage<::pg_query::AlterSeqStmt>(Arena*); template<> ::pg_query::AlterStatsStmt* Arena::CreateMaybeMessage<::pg_query::AlterStatsStmt>(Arena*); template<> ::pg_query::AlterSubscriptionStmt* Arena::CreateMaybeMessage<::pg_query::AlterSubscriptionStmt>(Arena*); template<> ::pg_query::AlterSystemStmt* Arena::CreateMaybeMessage<::pg_query::AlterSystemStmt>(Arena*); template<> ::pg_query::AlterTSConfigurationStmt* Arena::CreateMaybeMessage<::pg_query::AlterTSConfigurationStmt>(Arena*); template<> ::pg_query::AlterTSDictionaryStmt* Arena::CreateMaybeMessage<::pg_query::AlterTSDictionaryStmt>(Arena*); template<> ::pg_query::AlterTableCmd* Arena::CreateMaybeMessage<::pg_query::AlterTableCmd>(Arena*); template<> ::pg_query::AlterTableMoveAllStmt* Arena::CreateMaybeMessage<::pg_query::AlterTableMoveAllStmt>(Arena*); template<> ::pg_query::AlterTableSpaceOptionsStmt* Arena::CreateMaybeMessage<::pg_query::AlterTableSpaceOptionsStmt>(Arena*); template<> ::pg_query::AlterTableStmt* Arena::CreateMaybeMessage<::pg_query::AlterTableStmt>(Arena*); template<> ::pg_query::AlterTypeStmt* Arena::CreateMaybeMessage<::pg_query::AlterTypeStmt>(Arena*); template<> ::pg_query::AlterUserMappingStmt* Arena::CreateMaybeMessage<::pg_query::AlterUserMappingStmt>(Arena*); template<> ::pg_query::AlternativeSubPlan* Arena::CreateMaybeMessage<::pg_query::AlternativeSubPlan>(Arena*); template<> ::pg_query::ArrayCoerceExpr* Arena::CreateMaybeMessage<::pg_query::ArrayCoerceExpr>(Arena*); template<> ::pg_query::ArrayExpr* Arena::CreateMaybeMessage<::pg_query::ArrayExpr>(Arena*); template<> ::pg_query::BitString* Arena::CreateMaybeMessage<::pg_query::BitString>(Arena*); template<> ::pg_query::BoolExpr* Arena::CreateMaybeMessage<::pg_query::BoolExpr>(Arena*); template<> ::pg_query::Boolean* Arena::CreateMaybeMessage<::pg_query::Boolean>(Arena*); template<> ::pg_query::BooleanTest* Arena::CreateMaybeMessage<::pg_query::BooleanTest>(Arena*); template<> ::pg_query::CTECycleClause* Arena::CreateMaybeMessage<::pg_query::CTECycleClause>(Arena*); template<> ::pg_query::CTESearchClause* Arena::CreateMaybeMessage<::pg_query::CTESearchClause>(Arena*); template<> ::pg_query::CallContext* Arena::CreateMaybeMessage<::pg_query::CallContext>(Arena*); template<> ::pg_query::CallStmt* Arena::CreateMaybeMessage<::pg_query::CallStmt>(Arena*); template<> ::pg_query::CaseExpr* Arena::CreateMaybeMessage<::pg_query::CaseExpr>(Arena*); template<> ::pg_query::CaseTestExpr* Arena::CreateMaybeMessage<::pg_query::CaseTestExpr>(Arena*); template<> ::pg_query::CaseWhen* Arena::CreateMaybeMessage<::pg_query::CaseWhen>(Arena*); template<> ::pg_query::CheckPointStmt* Arena::CreateMaybeMessage<::pg_query::CheckPointStmt>(Arena*); template<> ::pg_query::ClosePortalStmt* Arena::CreateMaybeMessage<::pg_query::ClosePortalStmt>(Arena*); template<> ::pg_query::ClusterStmt* Arena::CreateMaybeMessage<::pg_query::ClusterStmt>(Arena*); template<> ::pg_query::CoalesceExpr* Arena::CreateMaybeMessage<::pg_query::CoalesceExpr>(Arena*); template<> ::pg_query::CoerceToDomain* Arena::CreateMaybeMessage<::pg_query::CoerceToDomain>(Arena*); template<> ::pg_query::CoerceToDomainValue* Arena::CreateMaybeMessage<::pg_query::CoerceToDomainValue>(Arena*); template<> ::pg_query::CoerceViaIO* Arena::CreateMaybeMessage<::pg_query::CoerceViaIO>(Arena*); template<> ::pg_query::CollateClause* Arena::CreateMaybeMessage<::pg_query::CollateClause>(Arena*); template<> ::pg_query::CollateExpr* Arena::CreateMaybeMessage<::pg_query::CollateExpr>(Arena*); template<> ::pg_query::ColumnDef* Arena::CreateMaybeMessage<::pg_query::ColumnDef>(Arena*); template<> ::pg_query::ColumnRef* Arena::CreateMaybeMessage<::pg_query::ColumnRef>(Arena*); template<> ::pg_query::CommentStmt* Arena::CreateMaybeMessage<::pg_query::CommentStmt>(Arena*); template<> ::pg_query::CommonTableExpr* Arena::CreateMaybeMessage<::pg_query::CommonTableExpr>(Arena*); template<> ::pg_query::CompositeTypeStmt* Arena::CreateMaybeMessage<::pg_query::CompositeTypeStmt>(Arena*); template<> ::pg_query::Constraint* Arena::CreateMaybeMessage<::pg_query::Constraint>(Arena*); template<> ::pg_query::ConstraintsSetStmt* Arena::CreateMaybeMessage<::pg_query::ConstraintsSetStmt>(Arena*); template<> ::pg_query::ConvertRowtypeExpr* Arena::CreateMaybeMessage<::pg_query::ConvertRowtypeExpr>(Arena*); template<> ::pg_query::CopyStmt* Arena::CreateMaybeMessage<::pg_query::CopyStmt>(Arena*); template<> ::pg_query::CreateAmStmt* Arena::CreateMaybeMessage<::pg_query::CreateAmStmt>(Arena*); template<> ::pg_query::CreateCastStmt* Arena::CreateMaybeMessage<::pg_query::CreateCastStmt>(Arena*); template<> ::pg_query::CreateConversionStmt* Arena::CreateMaybeMessage<::pg_query::CreateConversionStmt>(Arena*); template<> ::pg_query::CreateDomainStmt* Arena::CreateMaybeMessage<::pg_query::CreateDomainStmt>(Arena*); template<> ::pg_query::CreateEnumStmt* Arena::CreateMaybeMessage<::pg_query::CreateEnumStmt>(Arena*); template<> ::pg_query::CreateEventTrigStmt* Arena::CreateMaybeMessage<::pg_query::CreateEventTrigStmt>(Arena*); template<> ::pg_query::CreateExtensionStmt* Arena::CreateMaybeMessage<::pg_query::CreateExtensionStmt>(Arena*); template<> ::pg_query::CreateFdwStmt* Arena::CreateMaybeMessage<::pg_query::CreateFdwStmt>(Arena*); template<> ::pg_query::CreateForeignServerStmt* Arena::CreateMaybeMessage<::pg_query::CreateForeignServerStmt>(Arena*); template<> ::pg_query::CreateForeignTableStmt* Arena::CreateMaybeMessage<::pg_query::CreateForeignTableStmt>(Arena*); template<> ::pg_query::CreateFunctionStmt* Arena::CreateMaybeMessage<::pg_query::CreateFunctionStmt>(Arena*); template<> ::pg_query::CreateOpClassItem* Arena::CreateMaybeMessage<::pg_query::CreateOpClassItem>(Arena*); template<> ::pg_query::CreateOpClassStmt* Arena::CreateMaybeMessage<::pg_query::CreateOpClassStmt>(Arena*); template<> ::pg_query::CreateOpFamilyStmt* Arena::CreateMaybeMessage<::pg_query::CreateOpFamilyStmt>(Arena*); template<> ::pg_query::CreatePLangStmt* Arena::CreateMaybeMessage<::pg_query::CreatePLangStmt>(Arena*); template<> ::pg_query::CreatePolicyStmt* Arena::CreateMaybeMessage<::pg_query::CreatePolicyStmt>(Arena*); template<> ::pg_query::CreatePublicationStmt* Arena::CreateMaybeMessage<::pg_query::CreatePublicationStmt>(Arena*); template<> ::pg_query::CreateRangeStmt* Arena::CreateMaybeMessage<::pg_query::CreateRangeStmt>(Arena*); template<> ::pg_query::CreateRoleStmt* Arena::CreateMaybeMessage<::pg_query::CreateRoleStmt>(Arena*); template<> ::pg_query::CreateSchemaStmt* Arena::CreateMaybeMessage<::pg_query::CreateSchemaStmt>(Arena*); template<> ::pg_query::CreateSeqStmt* Arena::CreateMaybeMessage<::pg_query::CreateSeqStmt>(Arena*); template<> ::pg_query::CreateStatsStmt* Arena::CreateMaybeMessage<::pg_query::CreateStatsStmt>(Arena*); template<> ::pg_query::CreateStmt* Arena::CreateMaybeMessage<::pg_query::CreateStmt>(Arena*); template<> ::pg_query::CreateSubscriptionStmt* Arena::CreateMaybeMessage<::pg_query::CreateSubscriptionStmt>(Arena*); template<> ::pg_query::CreateTableAsStmt* Arena::CreateMaybeMessage<::pg_query::CreateTableAsStmt>(Arena*); template<> ::pg_query::CreateTableSpaceStmt* Arena::CreateMaybeMessage<::pg_query::CreateTableSpaceStmt>(Arena*); template<> ::pg_query::CreateTransformStmt* Arena::CreateMaybeMessage<::pg_query::CreateTransformStmt>(Arena*); template<> ::pg_query::CreateTrigStmt* Arena::CreateMaybeMessage<::pg_query::CreateTrigStmt>(Arena*); template<> ::pg_query::CreateUserMappingStmt* Arena::CreateMaybeMessage<::pg_query::CreateUserMappingStmt>(Arena*); template<> ::pg_query::CreatedbStmt* Arena::CreateMaybeMessage<::pg_query::CreatedbStmt>(Arena*); template<> ::pg_query::CurrentOfExpr* Arena::CreateMaybeMessage<::pg_query::CurrentOfExpr>(Arena*); template<> ::pg_query::DeallocateStmt* Arena::CreateMaybeMessage<::pg_query::DeallocateStmt>(Arena*); template<> ::pg_query::DeclareCursorStmt* Arena::CreateMaybeMessage<::pg_query::DeclareCursorStmt>(Arena*); template<> ::pg_query::DefElem* Arena::CreateMaybeMessage<::pg_query::DefElem>(Arena*); template<> ::pg_query::DefineStmt* Arena::CreateMaybeMessage<::pg_query::DefineStmt>(Arena*); template<> ::pg_query::DeleteStmt* Arena::CreateMaybeMessage<::pg_query::DeleteStmt>(Arena*); template<> ::pg_query::DiscardStmt* Arena::CreateMaybeMessage<::pg_query::DiscardStmt>(Arena*); template<> ::pg_query::DistinctExpr* Arena::CreateMaybeMessage<::pg_query::DistinctExpr>(Arena*); template<> ::pg_query::DoStmt* Arena::CreateMaybeMessage<::pg_query::DoStmt>(Arena*); template<> ::pg_query::DropOwnedStmt* Arena::CreateMaybeMessage<::pg_query::DropOwnedStmt>(Arena*); template<> ::pg_query::DropRoleStmt* Arena::CreateMaybeMessage<::pg_query::DropRoleStmt>(Arena*); template<> ::pg_query::DropStmt* Arena::CreateMaybeMessage<::pg_query::DropStmt>(Arena*); template<> ::pg_query::DropSubscriptionStmt* Arena::CreateMaybeMessage<::pg_query::DropSubscriptionStmt>(Arena*); template<> ::pg_query::DropTableSpaceStmt* Arena::CreateMaybeMessage<::pg_query::DropTableSpaceStmt>(Arena*); template<> ::pg_query::DropUserMappingStmt* Arena::CreateMaybeMessage<::pg_query::DropUserMappingStmt>(Arena*); template<> ::pg_query::DropdbStmt* Arena::CreateMaybeMessage<::pg_query::DropdbStmt>(Arena*); template<> ::pg_query::ExecuteStmt* Arena::CreateMaybeMessage<::pg_query::ExecuteStmt>(Arena*); template<> ::pg_query::ExplainStmt* Arena::CreateMaybeMessage<::pg_query::ExplainStmt>(Arena*); template<> ::pg_query::FetchStmt* Arena::CreateMaybeMessage<::pg_query::FetchStmt>(Arena*); template<> ::pg_query::FieldSelect* Arena::CreateMaybeMessage<::pg_query::FieldSelect>(Arena*); template<> ::pg_query::FieldStore* Arena::CreateMaybeMessage<::pg_query::FieldStore>(Arena*); template<> ::pg_query::Float* Arena::CreateMaybeMessage<::pg_query::Float>(Arena*); template<> ::pg_query::FromExpr* Arena::CreateMaybeMessage<::pg_query::FromExpr>(Arena*); template<> ::pg_query::FuncCall* Arena::CreateMaybeMessage<::pg_query::FuncCall>(Arena*); template<> ::pg_query::FuncExpr* Arena::CreateMaybeMessage<::pg_query::FuncExpr>(Arena*); template<> ::pg_query::FunctionParameter* Arena::CreateMaybeMessage<::pg_query::FunctionParameter>(Arena*); template<> ::pg_query::GrantRoleStmt* Arena::CreateMaybeMessage<::pg_query::GrantRoleStmt>(Arena*); template<> ::pg_query::GrantStmt* Arena::CreateMaybeMessage<::pg_query::GrantStmt>(Arena*); template<> ::pg_query::GroupingFunc* Arena::CreateMaybeMessage<::pg_query::GroupingFunc>(Arena*); template<> ::pg_query::GroupingSet* Arena::CreateMaybeMessage<::pg_query::GroupingSet>(Arena*); template<> ::pg_query::ImportForeignSchemaStmt* Arena::CreateMaybeMessage<::pg_query::ImportForeignSchemaStmt>(Arena*); template<> ::pg_query::IndexElem* Arena::CreateMaybeMessage<::pg_query::IndexElem>(Arena*); template<> ::pg_query::IndexStmt* Arena::CreateMaybeMessage<::pg_query::IndexStmt>(Arena*); template<> ::pg_query::InferClause* Arena::CreateMaybeMessage<::pg_query::InferClause>(Arena*); template<> ::pg_query::InferenceElem* Arena::CreateMaybeMessage<::pg_query::InferenceElem>(Arena*); template<> ::pg_query::InlineCodeBlock* Arena::CreateMaybeMessage<::pg_query::InlineCodeBlock>(Arena*); template<> ::pg_query::InsertStmt* Arena::CreateMaybeMessage<::pg_query::InsertStmt>(Arena*); template<> ::pg_query::IntList* Arena::CreateMaybeMessage<::pg_query::IntList>(Arena*); template<> ::pg_query::Integer* Arena::CreateMaybeMessage<::pg_query::Integer>(Arena*); template<> ::pg_query::IntoClause* Arena::CreateMaybeMessage<::pg_query::IntoClause>(Arena*); template<> ::pg_query::JoinExpr* Arena::CreateMaybeMessage<::pg_query::JoinExpr>(Arena*); template<> ::pg_query::List* Arena::CreateMaybeMessage<::pg_query::List>(Arena*); template<> ::pg_query::ListenStmt* Arena::CreateMaybeMessage<::pg_query::ListenStmt>(Arena*); template<> ::pg_query::LoadStmt* Arena::CreateMaybeMessage<::pg_query::LoadStmt>(Arena*); template<> ::pg_query::LockStmt* Arena::CreateMaybeMessage<::pg_query::LockStmt>(Arena*); template<> ::pg_query::LockingClause* Arena::CreateMaybeMessage<::pg_query::LockingClause>(Arena*); template<> ::pg_query::MergeAction* Arena::CreateMaybeMessage<::pg_query::MergeAction>(Arena*); template<> ::pg_query::MergeStmt* Arena::CreateMaybeMessage<::pg_query::MergeStmt>(Arena*); template<> ::pg_query::MergeWhenClause* Arena::CreateMaybeMessage<::pg_query::MergeWhenClause>(Arena*); template<> ::pg_query::MinMaxExpr* Arena::CreateMaybeMessage<::pg_query::MinMaxExpr>(Arena*); template<> ::pg_query::MultiAssignRef* Arena::CreateMaybeMessage<::pg_query::MultiAssignRef>(Arena*); template<> ::pg_query::NamedArgExpr* Arena::CreateMaybeMessage<::pg_query::NamedArgExpr>(Arena*); template<> ::pg_query::NextValueExpr* Arena::CreateMaybeMessage<::pg_query::NextValueExpr>(Arena*); template<> ::pg_query::Node* Arena::CreateMaybeMessage<::pg_query::Node>(Arena*); template<> ::pg_query::NotifyStmt* Arena::CreateMaybeMessage<::pg_query::NotifyStmt>(Arena*); template<> ::pg_query::NullIfExpr* Arena::CreateMaybeMessage<::pg_query::NullIfExpr>(Arena*); template<> ::pg_query::NullTest* Arena::CreateMaybeMessage<::pg_query::NullTest>(Arena*); template<> ::pg_query::ObjectWithArgs* Arena::CreateMaybeMessage<::pg_query::ObjectWithArgs>(Arena*); template<> ::pg_query::OidList* Arena::CreateMaybeMessage<::pg_query::OidList>(Arena*); template<> ::pg_query::OnConflictClause* Arena::CreateMaybeMessage<::pg_query::OnConflictClause>(Arena*); template<> ::pg_query::OnConflictExpr* Arena::CreateMaybeMessage<::pg_query::OnConflictExpr>(Arena*); template<> ::pg_query::OpExpr* Arena::CreateMaybeMessage<::pg_query::OpExpr>(Arena*); template<> ::pg_query::PLAssignStmt* Arena::CreateMaybeMessage<::pg_query::PLAssignStmt>(Arena*); template<> ::pg_query::Param* Arena::CreateMaybeMessage<::pg_query::Param>(Arena*); template<> ::pg_query::ParamRef* Arena::CreateMaybeMessage<::pg_query::ParamRef>(Arena*); template<> ::pg_query::ParseResult* Arena::CreateMaybeMessage<::pg_query::ParseResult>(Arena*); template<> ::pg_query::PartitionBoundSpec* Arena::CreateMaybeMessage<::pg_query::PartitionBoundSpec>(Arena*); template<> ::pg_query::PartitionCmd* Arena::CreateMaybeMessage<::pg_query::PartitionCmd>(Arena*); template<> ::pg_query::PartitionElem* Arena::CreateMaybeMessage<::pg_query::PartitionElem>(Arena*); template<> ::pg_query::PartitionRangeDatum* Arena::CreateMaybeMessage<::pg_query::PartitionRangeDatum>(Arena*); template<> ::pg_query::PartitionSpec* Arena::CreateMaybeMessage<::pg_query::PartitionSpec>(Arena*); template<> ::pg_query::PrepareStmt* Arena::CreateMaybeMessage<::pg_query::PrepareStmt>(Arena*); template<> ::pg_query::PublicationObjSpec* Arena::CreateMaybeMessage<::pg_query::PublicationObjSpec>(Arena*); template<> ::pg_query::PublicationTable* Arena::CreateMaybeMessage<::pg_query::PublicationTable>(Arena*); template<> ::pg_query::Query* Arena::CreateMaybeMessage<::pg_query::Query>(Arena*); template<> ::pg_query::RangeFunction* Arena::CreateMaybeMessage<::pg_query::RangeFunction>(Arena*); template<> ::pg_query::RangeSubselect* Arena::CreateMaybeMessage<::pg_query::RangeSubselect>(Arena*); template<> ::pg_query::RangeTableFunc* Arena::CreateMaybeMessage<::pg_query::RangeTableFunc>(Arena*); template<> ::pg_query::RangeTableFuncCol* Arena::CreateMaybeMessage<::pg_query::RangeTableFuncCol>(Arena*); template<> ::pg_query::RangeTableSample* Arena::CreateMaybeMessage<::pg_query::RangeTableSample>(Arena*); template<> ::pg_query::RangeTblEntry* Arena::CreateMaybeMessage<::pg_query::RangeTblEntry>(Arena*); template<> ::pg_query::RangeTblFunction* Arena::CreateMaybeMessage<::pg_query::RangeTblFunction>(Arena*); template<> ::pg_query::RangeTblRef* Arena::CreateMaybeMessage<::pg_query::RangeTblRef>(Arena*); template<> ::pg_query::RangeVar* Arena::CreateMaybeMessage<::pg_query::RangeVar>(Arena*); template<> ::pg_query::RawStmt* Arena::CreateMaybeMessage<::pg_query::RawStmt>(Arena*); template<> ::pg_query::ReassignOwnedStmt* Arena::CreateMaybeMessage<::pg_query::ReassignOwnedStmt>(Arena*); template<> ::pg_query::RefreshMatViewStmt* Arena::CreateMaybeMessage<::pg_query::RefreshMatViewStmt>(Arena*); template<> ::pg_query::ReindexStmt* Arena::CreateMaybeMessage<::pg_query::ReindexStmt>(Arena*); template<> ::pg_query::RelabelType* Arena::CreateMaybeMessage<::pg_query::RelabelType>(Arena*); template<> ::pg_query::RenameStmt* Arena::CreateMaybeMessage<::pg_query::RenameStmt>(Arena*); template<> ::pg_query::ReplicaIdentityStmt* Arena::CreateMaybeMessage<::pg_query::ReplicaIdentityStmt>(Arena*); template<> ::pg_query::ResTarget* Arena::CreateMaybeMessage<::pg_query::ResTarget>(Arena*); template<> ::pg_query::ReturnStmt* Arena::CreateMaybeMessage<::pg_query::ReturnStmt>(Arena*); template<> ::pg_query::RoleSpec* Arena::CreateMaybeMessage<::pg_query::RoleSpec>(Arena*); template<> ::pg_query::RowCompareExpr* Arena::CreateMaybeMessage<::pg_query::RowCompareExpr>(Arena*); template<> ::pg_query::RowExpr* Arena::CreateMaybeMessage<::pg_query::RowExpr>(Arena*); template<> ::pg_query::RowMarkClause* Arena::CreateMaybeMessage<::pg_query::RowMarkClause>(Arena*); template<> ::pg_query::RuleStmt* Arena::CreateMaybeMessage<::pg_query::RuleStmt>(Arena*); template<> ::pg_query::SQLValueFunction* Arena::CreateMaybeMessage<::pg_query::SQLValueFunction>(Arena*); template<> ::pg_query::ScalarArrayOpExpr* Arena::CreateMaybeMessage<::pg_query::ScalarArrayOpExpr>(Arena*); template<> ::pg_query::ScanResult* Arena::CreateMaybeMessage<::pg_query::ScanResult>(Arena*); template<> ::pg_query::ScanToken* Arena::CreateMaybeMessage<::pg_query::ScanToken>(Arena*); template<> ::pg_query::SecLabelStmt* Arena::CreateMaybeMessage<::pg_query::SecLabelStmt>(Arena*); template<> ::pg_query::SelectStmt* Arena::CreateMaybeMessage<::pg_query::SelectStmt>(Arena*); template<> ::pg_query::SetOperationStmt* Arena::CreateMaybeMessage<::pg_query::SetOperationStmt>(Arena*); template<> ::pg_query::SetToDefault* Arena::CreateMaybeMessage<::pg_query::SetToDefault>(Arena*); template<> ::pg_query::SortBy* Arena::CreateMaybeMessage<::pg_query::SortBy>(Arena*); template<> ::pg_query::SortGroupClause* Arena::CreateMaybeMessage<::pg_query::SortGroupClause>(Arena*); template<> ::pg_query::StatsElem* Arena::CreateMaybeMessage<::pg_query::StatsElem>(Arena*); template<> ::pg_query::String* Arena::CreateMaybeMessage<::pg_query::String>(Arena*); template<> ::pg_query::SubLink* Arena::CreateMaybeMessage<::pg_query::SubLink>(Arena*); template<> ::pg_query::SubPlan* Arena::CreateMaybeMessage<::pg_query::SubPlan>(Arena*); template<> ::pg_query::SubscriptingRef* Arena::CreateMaybeMessage<::pg_query::SubscriptingRef>(Arena*); template<> ::pg_query::TableFunc* Arena::CreateMaybeMessage<::pg_query::TableFunc>(Arena*); template<> ::pg_query::TableLikeClause* Arena::CreateMaybeMessage<::pg_query::TableLikeClause>(Arena*); template<> ::pg_query::TableSampleClause* Arena::CreateMaybeMessage<::pg_query::TableSampleClause>(Arena*); template<> ::pg_query::TargetEntry* Arena::CreateMaybeMessage<::pg_query::TargetEntry>(Arena*); template<> ::pg_query::TransactionStmt* Arena::CreateMaybeMessage<::pg_query::TransactionStmt>(Arena*); template<> ::pg_query::TriggerTransition* Arena::CreateMaybeMessage<::pg_query::TriggerTransition>(Arena*); template<> ::pg_query::TruncateStmt* Arena::CreateMaybeMessage<::pg_query::TruncateStmt>(Arena*); template<> ::pg_query::TypeCast* Arena::CreateMaybeMessage<::pg_query::TypeCast>(Arena*); template<> ::pg_query::TypeName* Arena::CreateMaybeMessage<::pg_query::TypeName>(Arena*); template<> ::pg_query::UnlistenStmt* Arena::CreateMaybeMessage<::pg_query::UnlistenStmt>(Arena*); template<> ::pg_query::UpdateStmt* Arena::CreateMaybeMessage<::pg_query::UpdateStmt>(Arena*); template<> ::pg_query::VacuumRelation* Arena::CreateMaybeMessage<::pg_query::VacuumRelation>(Arena*); template<> ::pg_query::VacuumStmt* Arena::CreateMaybeMessage<::pg_query::VacuumStmt>(Arena*); template<> ::pg_query::Var* Arena::CreateMaybeMessage<::pg_query::Var>(Arena*); template<> ::pg_query::VariableSetStmt* Arena::CreateMaybeMessage<::pg_query::VariableSetStmt>(Arena*); template<> ::pg_query::VariableShowStmt* Arena::CreateMaybeMessage<::pg_query::VariableShowStmt>(Arena*); template<> ::pg_query::ViewStmt* Arena::CreateMaybeMessage<::pg_query::ViewStmt>(Arena*); template<> ::pg_query::WindowClause* Arena::CreateMaybeMessage<::pg_query::WindowClause>(Arena*); template<> ::pg_query::WindowDef* Arena::CreateMaybeMessage<::pg_query::WindowDef>(Arena*); template<> ::pg_query::WindowFunc* Arena::CreateMaybeMessage<::pg_query::WindowFunc>(Arena*); template<> ::pg_query::WithCheckOption* Arena::CreateMaybeMessage<::pg_query::WithCheckOption>(Arena*); template<> ::pg_query::WithClause* Arena::CreateMaybeMessage<::pg_query::WithClause>(Arena*); template<> ::pg_query::XmlExpr* Arena::CreateMaybeMessage<::pg_query::XmlExpr>(Arena*); template<> ::pg_query::XmlSerialize* Arena::CreateMaybeMessage<::pg_query::XmlSerialize>(Arena*); PROTOBUF_NAMESPACE_CLOSE namespace pg_query { enum OverridingKind : int { OVERRIDING_KIND_UNDEFINED = 0, OVERRIDING_NOT_SET = 1, OVERRIDING_USER_VALUE = 2, OVERRIDING_SYSTEM_VALUE = 3, OverridingKind_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), OverridingKind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool OverridingKind_IsValid(int value); constexpr OverridingKind OverridingKind_MIN = OVERRIDING_KIND_UNDEFINED; constexpr OverridingKind OverridingKind_MAX = OVERRIDING_SYSTEM_VALUE; constexpr int OverridingKind_ARRAYSIZE = OverridingKind_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* OverridingKind_descriptor(); template inline const std::string& OverridingKind_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function OverridingKind_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( OverridingKind_descriptor(), enum_t_value); } inline bool OverridingKind_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OverridingKind* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( OverridingKind_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::min(), QuerySource_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool QuerySource_IsValid(int value); constexpr QuerySource QuerySource_MIN = QUERY_SOURCE_UNDEFINED; constexpr QuerySource QuerySource_MAX = QSRC_NON_INSTEAD_RULE; constexpr int QuerySource_ARRAYSIZE = QuerySource_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* QuerySource_descriptor(); template inline const std::string& QuerySource_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function QuerySource_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( QuerySource_descriptor(), enum_t_value); } inline bool QuerySource_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, QuerySource* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( QuerySource_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::min(), SortByDir_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool SortByDir_IsValid(int value); constexpr SortByDir SortByDir_MIN = SORT_BY_DIR_UNDEFINED; constexpr SortByDir SortByDir_MAX = SORTBY_USING; constexpr int SortByDir_ARRAYSIZE = SortByDir_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SortByDir_descriptor(); template inline const std::string& SortByDir_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function SortByDir_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( SortByDir_descriptor(), enum_t_value); } inline bool SortByDir_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SortByDir* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( SortByDir_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::min(), SortByNulls_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool SortByNulls_IsValid(int value); constexpr SortByNulls SortByNulls_MIN = SORT_BY_NULLS_UNDEFINED; constexpr SortByNulls SortByNulls_MAX = SORTBY_NULLS_LAST; constexpr int SortByNulls_ARRAYSIZE = SortByNulls_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SortByNulls_descriptor(); template inline const std::string& SortByNulls_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function SortByNulls_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( SortByNulls_descriptor(), enum_t_value); } inline bool SortByNulls_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SortByNulls* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( SortByNulls_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::min(), SetQuantifier_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool SetQuantifier_IsValid(int value); constexpr SetQuantifier SetQuantifier_MIN = SET_QUANTIFIER_UNDEFINED; constexpr SetQuantifier SetQuantifier_MAX = SET_QUANTIFIER_DISTINCT; constexpr int SetQuantifier_ARRAYSIZE = SetQuantifier_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SetQuantifier_descriptor(); template inline const std::string& SetQuantifier_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function SetQuantifier_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( SetQuantifier_descriptor(), enum_t_value); } inline bool SetQuantifier_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SetQuantifier* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( 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::min(), A_Expr_Kind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool A_Expr_Kind_IsValid(int value); constexpr A_Expr_Kind A_Expr_Kind_MIN = A_EXPR_KIND_UNDEFINED; constexpr A_Expr_Kind A_Expr_Kind_MAX = AEXPR_NOT_BETWEEN_SYM; constexpr int A_Expr_Kind_ARRAYSIZE = A_Expr_Kind_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* A_Expr_Kind_descriptor(); template inline const std::string& A_Expr_Kind_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function A_Expr_Kind_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( A_Expr_Kind_descriptor(), enum_t_value); } inline bool A_Expr_Kind_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, A_Expr_Kind* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( A_Expr_Kind_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::min(), RoleSpecType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool RoleSpecType_IsValid(int value); constexpr RoleSpecType RoleSpecType_MIN = ROLE_SPEC_TYPE_UNDEFINED; constexpr RoleSpecType RoleSpecType_MAX = ROLESPEC_PUBLIC; constexpr int RoleSpecType_ARRAYSIZE = RoleSpecType_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RoleSpecType_descriptor(); template inline const std::string& RoleSpecType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function RoleSpecType_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( RoleSpecType_descriptor(), enum_t_value); } inline bool RoleSpecType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RoleSpecType* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( RoleSpecType_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::min(), TableLikeOption_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool TableLikeOption_IsValid(int value); constexpr TableLikeOption TableLikeOption_MIN = TABLE_LIKE_OPTION_UNDEFINED; constexpr TableLikeOption TableLikeOption_MAX = CREATE_TABLE_LIKE_ALL; constexpr int TableLikeOption_ARRAYSIZE = TableLikeOption_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TableLikeOption_descriptor(); template inline const std::string& TableLikeOption_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function TableLikeOption_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( TableLikeOption_descriptor(), enum_t_value); } inline bool TableLikeOption_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TableLikeOption* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( TableLikeOption_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::min(), DefElemAction_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool DefElemAction_IsValid(int value); constexpr DefElemAction DefElemAction_MIN = DEF_ELEM_ACTION_UNDEFINED; constexpr DefElemAction DefElemAction_MAX = DEFELEM_DROP; constexpr int DefElemAction_ARRAYSIZE = DefElemAction_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DefElemAction_descriptor(); template inline const std::string& DefElemAction_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function DefElemAction_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( DefElemAction_descriptor(), enum_t_value); } inline bool DefElemAction_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DefElemAction* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( DefElemAction_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::min(), PartitionRangeDatumKind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool PartitionRangeDatumKind_IsValid(int value); constexpr PartitionRangeDatumKind PartitionRangeDatumKind_MIN = PARTITION_RANGE_DATUM_KIND_UNDEFINED; constexpr PartitionRangeDatumKind PartitionRangeDatumKind_MAX = PARTITION_RANGE_DATUM_MAXVALUE; constexpr int PartitionRangeDatumKind_ARRAYSIZE = PartitionRangeDatumKind_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PartitionRangeDatumKind_descriptor(); template inline const std::string& PartitionRangeDatumKind_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function PartitionRangeDatumKind_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( PartitionRangeDatumKind_descriptor(), enum_t_value); } inline bool PartitionRangeDatumKind_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PartitionRangeDatumKind* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( PartitionRangeDatumKind_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::min(), RTEKind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool RTEKind_IsValid(int value); constexpr RTEKind RTEKind_MIN = RTEKIND_UNDEFINED; constexpr RTEKind RTEKind_MAX = RTE_RESULT; constexpr int RTEKind_ARRAYSIZE = RTEKind_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RTEKind_descriptor(); template inline const std::string& RTEKind_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function RTEKind_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( RTEKind_descriptor(), enum_t_value); } inline bool RTEKind_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RTEKind* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( RTEKind_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::min(), WCOKind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool WCOKind_IsValid(int value); constexpr WCOKind WCOKind_MIN = WCOKIND_UNDEFINED; constexpr WCOKind WCOKind_MAX = WCO_RLS_MERGE_DELETE_CHECK; constexpr int WCOKind_ARRAYSIZE = WCOKind_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WCOKind_descriptor(); template inline const std::string& WCOKind_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function WCOKind_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( WCOKind_descriptor(), enum_t_value); } inline bool WCOKind_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WCOKind* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( WCOKind_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::min(), GroupingSetKind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool GroupingSetKind_IsValid(int value); constexpr GroupingSetKind GroupingSetKind_MIN = GROUPING_SET_KIND_UNDEFINED; constexpr GroupingSetKind GroupingSetKind_MAX = GROUPING_SET_SETS; constexpr int GroupingSetKind_ARRAYSIZE = GroupingSetKind_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GroupingSetKind_descriptor(); template inline const std::string& GroupingSetKind_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function GroupingSetKind_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( GroupingSetKind_descriptor(), enum_t_value); } inline bool GroupingSetKind_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, GroupingSetKind* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( GroupingSetKind_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::min(), CTEMaterialize_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool CTEMaterialize_IsValid(int value); constexpr CTEMaterialize CTEMaterialize_MIN = CTEMATERIALIZE_UNDEFINED; constexpr CTEMaterialize CTEMaterialize_MAX = CTEMaterializeNever; constexpr int CTEMaterialize_ARRAYSIZE = CTEMaterialize_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CTEMaterialize_descriptor(); template inline const std::string& CTEMaterialize_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function CTEMaterialize_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( CTEMaterialize_descriptor(), enum_t_value); } inline bool CTEMaterialize_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CTEMaterialize* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( CTEMaterialize_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::min(), SetOperation_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool SetOperation_IsValid(int value); constexpr SetOperation SetOperation_MIN = SET_OPERATION_UNDEFINED; constexpr SetOperation SetOperation_MAX = SETOP_EXCEPT; constexpr int SetOperation_ARRAYSIZE = SetOperation_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SetOperation_descriptor(); template inline const std::string& SetOperation_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function SetOperation_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( SetOperation_descriptor(), enum_t_value); } inline bool SetOperation_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SetOperation* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( SetOperation_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::min(), ObjectType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool ObjectType_IsValid(int value); constexpr ObjectType ObjectType_MIN = OBJECT_TYPE_UNDEFINED; constexpr ObjectType ObjectType_MAX = OBJECT_VIEW; constexpr int ObjectType_ARRAYSIZE = ObjectType_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ObjectType_descriptor(); template inline const std::string& ObjectType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function ObjectType_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( ObjectType_descriptor(), enum_t_value); } inline bool ObjectType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ObjectType* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( ObjectType_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::min(), DropBehavior_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool DropBehavior_IsValid(int value); constexpr DropBehavior DropBehavior_MIN = DROP_BEHAVIOR_UNDEFINED; constexpr DropBehavior DropBehavior_MAX = DROP_CASCADE; constexpr int DropBehavior_ARRAYSIZE = DropBehavior_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DropBehavior_descriptor(); template inline const std::string& DropBehavior_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function DropBehavior_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( DropBehavior_descriptor(), enum_t_value); } inline bool DropBehavior_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DropBehavior* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( DropBehavior_descriptor(), name, value); } enum AlterTableType : int { ALTER_TABLE_TYPE_UNDEFINED = 0, AT_AddColumn = 1, AT_AddColumnRecurse = 2, AT_AddColumnToView = 3, AT_ColumnDefault = 4, AT_CookedColumnDefault = 5, AT_DropNotNull = 6, AT_SetNotNull = 7, AT_DropExpression = 8, AT_CheckNotNull = 9, AT_SetStatistics = 10, AT_SetOptions = 11, AT_ResetOptions = 12, AT_SetStorage = 13, AT_SetCompression = 14, AT_DropColumn = 15, AT_DropColumnRecurse = 16, AT_AddIndex = 17, AT_ReAddIndex = 18, AT_AddConstraint = 19, AT_AddConstraintRecurse = 20, AT_ReAddConstraint = 21, AT_ReAddDomainConstraint = 22, AT_AlterConstraint = 23, AT_ValidateConstraint = 24, AT_ValidateConstraintRecurse = 25, AT_AddIndexConstraint = 26, AT_DropConstraint = 27, AT_DropConstraintRecurse = 28, AT_ReAddComment = 29, AT_AlterColumnType = 30, AT_AlterColumnGenericOptions = 31, AT_ChangeOwner = 32, AT_ClusterOn = 33, AT_DropCluster = 34, AT_SetLogged = 35, AT_SetUnLogged = 36, AT_DropOids = 37, AT_SetAccessMethod = 38, AT_SetTableSpace = 39, AT_SetRelOptions = 40, AT_ResetRelOptions = 41, AT_ReplaceRelOptions = 42, AT_EnableTrig = 43, AT_EnableAlwaysTrig = 44, AT_EnableReplicaTrig = 45, AT_DisableTrig = 46, AT_EnableTrigAll = 47, AT_DisableTrigAll = 48, AT_EnableTrigUser = 49, AT_DisableTrigUser = 50, AT_EnableRule = 51, AT_EnableAlwaysRule = 52, AT_EnableReplicaRule = 53, AT_DisableRule = 54, AT_AddInherit = 55, AT_DropInherit = 56, AT_AddOf = 57, AT_DropOf = 58, AT_ReplicaIdentity = 59, AT_EnableRowSecurity = 60, AT_DisableRowSecurity = 61, AT_ForceRowSecurity = 62, AT_NoForceRowSecurity = 63, AT_GenericOptions = 64, AT_AttachPartition = 65, AT_DetachPartition = 66, AT_DetachPartitionFinalize = 67, AT_AddIdentity = 68, AT_SetIdentity = 69, AT_DropIdentity = 70, AT_ReAddStatistics = 71, AlterTableType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), AlterTableType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool AlterTableType_IsValid(int value); constexpr AlterTableType AlterTableType_MIN = ALTER_TABLE_TYPE_UNDEFINED; constexpr AlterTableType AlterTableType_MAX = AT_ReAddStatistics; constexpr int AlterTableType_ARRAYSIZE = AlterTableType_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AlterTableType_descriptor(); template inline const std::string& AlterTableType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function AlterTableType_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( AlterTableType_descriptor(), enum_t_value); } inline bool AlterTableType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AlterTableType* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( AlterTableType_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::min(), GrantTargetType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool GrantTargetType_IsValid(int value); constexpr GrantTargetType GrantTargetType_MIN = GRANT_TARGET_TYPE_UNDEFINED; constexpr GrantTargetType GrantTargetType_MAX = ACL_TARGET_DEFAULTS; constexpr int GrantTargetType_ARRAYSIZE = GrantTargetType_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GrantTargetType_descriptor(); template inline const std::string& GrantTargetType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function GrantTargetType_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( GrantTargetType_descriptor(), enum_t_value); } inline bool GrantTargetType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, GrantTargetType* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( GrantTargetType_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::min(), VariableSetKind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool VariableSetKind_IsValid(int value); constexpr VariableSetKind VariableSetKind_MIN = VARIABLE_SET_KIND_UNDEFINED; constexpr VariableSetKind VariableSetKind_MAX = VAR_RESET_ALL; constexpr int VariableSetKind_ARRAYSIZE = VariableSetKind_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* VariableSetKind_descriptor(); template inline const std::string& VariableSetKind_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function VariableSetKind_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( VariableSetKind_descriptor(), enum_t_value); } inline bool VariableSetKind_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, VariableSetKind* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( VariableSetKind_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::min(), ConstrType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool ConstrType_IsValid(int value); constexpr ConstrType ConstrType_MIN = CONSTR_TYPE_UNDEFINED; constexpr ConstrType ConstrType_MAX = CONSTR_ATTR_IMMEDIATE; constexpr int ConstrType_ARRAYSIZE = ConstrType_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ConstrType_descriptor(); template inline const std::string& ConstrType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function ConstrType_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( ConstrType_descriptor(), enum_t_value); } inline bool ConstrType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConstrType* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( ConstrType_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::min(), ImportForeignSchemaType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool ImportForeignSchemaType_IsValid(int value); constexpr ImportForeignSchemaType ImportForeignSchemaType_MIN = IMPORT_FOREIGN_SCHEMA_TYPE_UNDEFINED; constexpr ImportForeignSchemaType ImportForeignSchemaType_MAX = FDW_IMPORT_SCHEMA_EXCEPT; constexpr int ImportForeignSchemaType_ARRAYSIZE = ImportForeignSchemaType_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ImportForeignSchemaType_descriptor(); template inline const std::string& ImportForeignSchemaType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function ImportForeignSchemaType_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( ImportForeignSchemaType_descriptor(), enum_t_value); } inline bool ImportForeignSchemaType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ImportForeignSchemaType* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( ImportForeignSchemaType_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::min(), RoleStmtType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool RoleStmtType_IsValid(int value); constexpr RoleStmtType RoleStmtType_MIN = ROLE_STMT_TYPE_UNDEFINED; constexpr RoleStmtType RoleStmtType_MAX = ROLESTMT_GROUP; constexpr int RoleStmtType_ARRAYSIZE = RoleStmtType_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RoleStmtType_descriptor(); template inline const std::string& RoleStmtType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function RoleStmtType_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( RoleStmtType_descriptor(), enum_t_value); } inline bool RoleStmtType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RoleStmtType* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( RoleStmtType_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::min(), FetchDirection_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool FetchDirection_IsValid(int value); constexpr FetchDirection FetchDirection_MIN = FETCH_DIRECTION_UNDEFINED; constexpr FetchDirection FetchDirection_MAX = FETCH_RELATIVE; constexpr int FetchDirection_ARRAYSIZE = FetchDirection_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FetchDirection_descriptor(); template inline const std::string& FetchDirection_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function FetchDirection_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( FetchDirection_descriptor(), enum_t_value); } inline bool FetchDirection_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FetchDirection* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( FetchDirection_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::min(), FunctionParameterMode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool FunctionParameterMode_IsValid(int value); constexpr FunctionParameterMode FunctionParameterMode_MIN = FUNCTION_PARAMETER_MODE_UNDEFINED; constexpr FunctionParameterMode FunctionParameterMode_MAX = FUNC_PARAM_DEFAULT; constexpr int FunctionParameterMode_ARRAYSIZE = FunctionParameterMode_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionParameterMode_descriptor(); template inline const std::string& FunctionParameterMode_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function FunctionParameterMode_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( FunctionParameterMode_descriptor(), enum_t_value); } inline bool FunctionParameterMode_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FunctionParameterMode* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( FunctionParameterMode_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::min(), TransactionStmtKind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool TransactionStmtKind_IsValid(int value); constexpr TransactionStmtKind TransactionStmtKind_MIN = TRANSACTION_STMT_KIND_UNDEFINED; constexpr TransactionStmtKind TransactionStmtKind_MAX = TRANS_STMT_ROLLBACK_PREPARED; constexpr int TransactionStmtKind_ARRAYSIZE = TransactionStmtKind_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TransactionStmtKind_descriptor(); template inline const std::string& TransactionStmtKind_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function TransactionStmtKind_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( TransactionStmtKind_descriptor(), enum_t_value); } inline bool TransactionStmtKind_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TransactionStmtKind* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( TransactionStmtKind_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::min(), ViewCheckOption_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool ViewCheckOption_IsValid(int value); constexpr ViewCheckOption ViewCheckOption_MIN = VIEW_CHECK_OPTION_UNDEFINED; constexpr ViewCheckOption ViewCheckOption_MAX = CASCADED_CHECK_OPTION; constexpr int ViewCheckOption_ARRAYSIZE = ViewCheckOption_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ViewCheckOption_descriptor(); template inline const std::string& ViewCheckOption_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function ViewCheckOption_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( ViewCheckOption_descriptor(), enum_t_value); } inline bool ViewCheckOption_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ViewCheckOption* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( ViewCheckOption_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::min(), DiscardMode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool DiscardMode_IsValid(int value); constexpr DiscardMode DiscardMode_MIN = DISCARD_MODE_UNDEFINED; constexpr DiscardMode DiscardMode_MAX = DISCARD_TEMP; constexpr int DiscardMode_ARRAYSIZE = DiscardMode_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DiscardMode_descriptor(); template inline const std::string& DiscardMode_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function DiscardMode_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( DiscardMode_descriptor(), enum_t_value); } inline bool DiscardMode_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DiscardMode* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( DiscardMode_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::min(), ReindexObjectType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool ReindexObjectType_IsValid(int value); constexpr ReindexObjectType ReindexObjectType_MIN = REINDEX_OBJECT_TYPE_UNDEFINED; constexpr ReindexObjectType ReindexObjectType_MAX = REINDEX_OBJECT_DATABASE; constexpr int ReindexObjectType_ARRAYSIZE = ReindexObjectType_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ReindexObjectType_descriptor(); template inline const std::string& ReindexObjectType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function ReindexObjectType_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( ReindexObjectType_descriptor(), enum_t_value); } inline bool ReindexObjectType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ReindexObjectType* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( ReindexObjectType_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::min(), AlterTSConfigType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool AlterTSConfigType_IsValid(int value); constexpr AlterTSConfigType AlterTSConfigType_MIN = ALTER_TSCONFIG_TYPE_UNDEFINED; constexpr AlterTSConfigType AlterTSConfigType_MAX = ALTER_TSCONFIG_DROP_MAPPING; constexpr int AlterTSConfigType_ARRAYSIZE = AlterTSConfigType_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AlterTSConfigType_descriptor(); template inline const std::string& AlterTSConfigType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function AlterTSConfigType_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( AlterTSConfigType_descriptor(), enum_t_value); } inline bool AlterTSConfigType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AlterTSConfigType* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( AlterTSConfigType_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::min(), PublicationObjSpecType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool PublicationObjSpecType_IsValid(int value); constexpr PublicationObjSpecType PublicationObjSpecType_MIN = PUBLICATION_OBJ_SPEC_TYPE_UNDEFINED; constexpr PublicationObjSpecType PublicationObjSpecType_MAX = PUBLICATIONOBJ_CONTINUATION; constexpr int PublicationObjSpecType_ARRAYSIZE = PublicationObjSpecType_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PublicationObjSpecType_descriptor(); template inline const std::string& PublicationObjSpecType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function PublicationObjSpecType_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( PublicationObjSpecType_descriptor(), enum_t_value); } inline bool PublicationObjSpecType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PublicationObjSpecType* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( 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::min(), AlterPublicationAction_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool AlterPublicationAction_IsValid(int value); constexpr AlterPublicationAction AlterPublicationAction_MIN = ALTER_PUBLICATION_ACTION_UNDEFINED; constexpr AlterPublicationAction AlterPublicationAction_MAX = AP_SetObjects; constexpr int AlterPublicationAction_ARRAYSIZE = AlterPublicationAction_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AlterPublicationAction_descriptor(); template inline const std::string& AlterPublicationAction_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function AlterPublicationAction_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( AlterPublicationAction_descriptor(), enum_t_value); } inline bool AlterPublicationAction_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AlterPublicationAction* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( 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::min(), AlterSubscriptionType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool AlterSubscriptionType_IsValid(int value); constexpr AlterSubscriptionType AlterSubscriptionType_MIN = ALTER_SUBSCRIPTION_TYPE_UNDEFINED; constexpr AlterSubscriptionType AlterSubscriptionType_MAX = ALTER_SUBSCRIPTION_SKIP; constexpr int AlterSubscriptionType_ARRAYSIZE = AlterSubscriptionType_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AlterSubscriptionType_descriptor(); template inline const std::string& AlterSubscriptionType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function AlterSubscriptionType_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( AlterSubscriptionType_descriptor(), enum_t_value); } inline bool AlterSubscriptionType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AlterSubscriptionType* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( AlterSubscriptionType_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::min(), OnCommitAction_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool OnCommitAction_IsValid(int value); constexpr OnCommitAction OnCommitAction_MIN = ON_COMMIT_ACTION_UNDEFINED; constexpr OnCommitAction OnCommitAction_MAX = ONCOMMIT_DROP; constexpr int OnCommitAction_ARRAYSIZE = OnCommitAction_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* OnCommitAction_descriptor(); template inline const std::string& OnCommitAction_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function OnCommitAction_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( OnCommitAction_descriptor(), enum_t_value); } inline bool OnCommitAction_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OnCommitAction* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( OnCommitAction_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::min(), ParamKind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool ParamKind_IsValid(int value); constexpr ParamKind ParamKind_MIN = PARAM_KIND_UNDEFINED; constexpr ParamKind ParamKind_MAX = PARAM_MULTIEXPR; constexpr int ParamKind_ARRAYSIZE = ParamKind_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ParamKind_descriptor(); template inline const std::string& ParamKind_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function ParamKind_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( ParamKind_descriptor(), enum_t_value); } inline bool ParamKind_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ParamKind* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( ParamKind_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::min(), CoercionContext_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool CoercionContext_IsValid(int value); constexpr CoercionContext CoercionContext_MIN = COERCION_CONTEXT_UNDEFINED; constexpr CoercionContext CoercionContext_MAX = COERCION_EXPLICIT; constexpr int CoercionContext_ARRAYSIZE = CoercionContext_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CoercionContext_descriptor(); template inline const std::string& CoercionContext_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function CoercionContext_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( CoercionContext_descriptor(), enum_t_value); } inline bool CoercionContext_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CoercionContext* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( CoercionContext_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::min(), CoercionForm_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool CoercionForm_IsValid(int value); constexpr CoercionForm CoercionForm_MIN = COERCION_FORM_UNDEFINED; constexpr CoercionForm CoercionForm_MAX = COERCE_SQL_SYNTAX; constexpr int CoercionForm_ARRAYSIZE = CoercionForm_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CoercionForm_descriptor(); template inline const std::string& CoercionForm_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function CoercionForm_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( CoercionForm_descriptor(), enum_t_value); } inline bool CoercionForm_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CoercionForm* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( CoercionForm_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::min(), BoolExprType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool BoolExprType_IsValid(int value); constexpr BoolExprType BoolExprType_MIN = BOOL_EXPR_TYPE_UNDEFINED; constexpr BoolExprType BoolExprType_MAX = NOT_EXPR; constexpr int BoolExprType_ARRAYSIZE = BoolExprType_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BoolExprType_descriptor(); template inline const std::string& BoolExprType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function BoolExprType_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( BoolExprType_descriptor(), enum_t_value); } inline bool BoolExprType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BoolExprType* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( BoolExprType_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::min(), SubLinkType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool SubLinkType_IsValid(int value); constexpr SubLinkType SubLinkType_MIN = SUB_LINK_TYPE_UNDEFINED; constexpr SubLinkType SubLinkType_MAX = CTE_SUBLINK; constexpr int SubLinkType_ARRAYSIZE = SubLinkType_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SubLinkType_descriptor(); template inline const std::string& SubLinkType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function SubLinkType_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( SubLinkType_descriptor(), enum_t_value); } inline bool SubLinkType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SubLinkType* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( SubLinkType_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::min(), RowCompareType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool RowCompareType_IsValid(int value); constexpr RowCompareType RowCompareType_MIN = ROW_COMPARE_TYPE_UNDEFINED; constexpr RowCompareType RowCompareType_MAX = ROWCOMPARE_NE; constexpr int RowCompareType_ARRAYSIZE = RowCompareType_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RowCompareType_descriptor(); template inline const std::string& RowCompareType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function RowCompareType_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( RowCompareType_descriptor(), enum_t_value); } inline bool RowCompareType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RowCompareType* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( RowCompareType_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::min(), MinMaxOp_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool MinMaxOp_IsValid(int value); constexpr MinMaxOp MinMaxOp_MIN = MIN_MAX_OP_UNDEFINED; constexpr MinMaxOp MinMaxOp_MAX = IS_LEAST; constexpr int MinMaxOp_ARRAYSIZE = MinMaxOp_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MinMaxOp_descriptor(); template inline const std::string& MinMaxOp_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function MinMaxOp_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( MinMaxOp_descriptor(), enum_t_value); } inline bool MinMaxOp_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MinMaxOp* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( MinMaxOp_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::min(), SQLValueFunctionOp_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool SQLValueFunctionOp_IsValid(int value); constexpr SQLValueFunctionOp SQLValueFunctionOp_MIN = SQLVALUE_FUNCTION_OP_UNDEFINED; constexpr SQLValueFunctionOp SQLValueFunctionOp_MAX = SVFOP_CURRENT_SCHEMA; constexpr int SQLValueFunctionOp_ARRAYSIZE = SQLValueFunctionOp_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SQLValueFunctionOp_descriptor(); template inline const std::string& SQLValueFunctionOp_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function SQLValueFunctionOp_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( SQLValueFunctionOp_descriptor(), enum_t_value); } inline bool SQLValueFunctionOp_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SQLValueFunctionOp* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( SQLValueFunctionOp_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::min(), XmlExprOp_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool XmlExprOp_IsValid(int value); constexpr XmlExprOp XmlExprOp_MIN = XML_EXPR_OP_UNDEFINED; constexpr XmlExprOp XmlExprOp_MAX = IS_DOCUMENT; constexpr int XmlExprOp_ARRAYSIZE = XmlExprOp_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* XmlExprOp_descriptor(); template inline const std::string& XmlExprOp_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function XmlExprOp_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( XmlExprOp_descriptor(), enum_t_value); } inline bool XmlExprOp_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, XmlExprOp* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( XmlExprOp_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::min(), XmlOptionType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool XmlOptionType_IsValid(int value); constexpr XmlOptionType XmlOptionType_MIN = XML_OPTION_TYPE_UNDEFINED; constexpr XmlOptionType XmlOptionType_MAX = XMLOPTION_CONTENT; constexpr int XmlOptionType_ARRAYSIZE = XmlOptionType_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* XmlOptionType_descriptor(); template inline const std::string& XmlOptionType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function XmlOptionType_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( XmlOptionType_descriptor(), enum_t_value); } inline bool XmlOptionType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, XmlOptionType* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( XmlOptionType_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::min(), NullTestType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool NullTestType_IsValid(int value); constexpr NullTestType NullTestType_MIN = NULL_TEST_TYPE_UNDEFINED; constexpr NullTestType NullTestType_MAX = IS_NOT_NULL; constexpr int NullTestType_ARRAYSIZE = NullTestType_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* NullTestType_descriptor(); template inline const std::string& NullTestType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function NullTestType_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( NullTestType_descriptor(), enum_t_value); } inline bool NullTestType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, NullTestType* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( NullTestType_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::min(), BoolTestType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool BoolTestType_IsValid(int value); constexpr BoolTestType BoolTestType_MIN = BOOL_TEST_TYPE_UNDEFINED; constexpr BoolTestType BoolTestType_MAX = IS_NOT_UNKNOWN; constexpr int BoolTestType_ARRAYSIZE = BoolTestType_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BoolTestType_descriptor(); template inline const std::string& BoolTestType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function BoolTestType_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( BoolTestType_descriptor(), enum_t_value); } inline bool BoolTestType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BoolTestType* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( BoolTestType_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::min(), CmdType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool CmdType_IsValid(int value); constexpr CmdType CmdType_MIN = CMD_TYPE_UNDEFINED; constexpr CmdType CmdType_MAX = CMD_NOTHING; constexpr int CmdType_ARRAYSIZE = CmdType_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CmdType_descriptor(); template inline const std::string& CmdType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function CmdType_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( CmdType_descriptor(), enum_t_value); } inline bool CmdType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CmdType* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( CmdType_descriptor(), name, value); } enum JoinType : int { JOIN_TYPE_UNDEFINED = 0, JOIN_INNER = 1, JOIN_LEFT = 2, JOIN_FULL = 3, JOIN_RIGHT = 4, JOIN_SEMI = 5, JOIN_ANTI = 6, JOIN_UNIQUE_OUTER = 7, JOIN_UNIQUE_INNER = 8, JoinType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), JoinType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool JoinType_IsValid(int value); constexpr JoinType JoinType_MIN = JOIN_TYPE_UNDEFINED; constexpr JoinType JoinType_MAX = JOIN_UNIQUE_INNER; constexpr int JoinType_ARRAYSIZE = JoinType_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* JoinType_descriptor(); template inline const std::string& JoinType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function JoinType_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( JoinType_descriptor(), enum_t_value); } inline bool JoinType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, JoinType* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( JoinType_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::min(), AggStrategy_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool AggStrategy_IsValid(int value); constexpr AggStrategy AggStrategy_MIN = AGG_STRATEGY_UNDEFINED; constexpr AggStrategy AggStrategy_MAX = AGG_MIXED; constexpr int AggStrategy_ARRAYSIZE = AggStrategy_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AggStrategy_descriptor(); template inline const std::string& AggStrategy_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function AggStrategy_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( AggStrategy_descriptor(), enum_t_value); } inline bool AggStrategy_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AggStrategy* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( AggStrategy_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::min(), AggSplit_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool AggSplit_IsValid(int value); constexpr AggSplit AggSplit_MIN = AGG_SPLIT_UNDEFINED; constexpr AggSplit AggSplit_MAX = AGGSPLIT_FINAL_DESERIAL; constexpr int AggSplit_ARRAYSIZE = AggSplit_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AggSplit_descriptor(); template inline const std::string& AggSplit_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function AggSplit_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( AggSplit_descriptor(), enum_t_value); } inline bool AggSplit_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AggSplit* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( AggSplit_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::min(), SetOpCmd_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool SetOpCmd_IsValid(int value); constexpr SetOpCmd SetOpCmd_MIN = SET_OP_CMD_UNDEFINED; constexpr SetOpCmd SetOpCmd_MAX = SETOPCMD_EXCEPT_ALL; constexpr int SetOpCmd_ARRAYSIZE = SetOpCmd_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SetOpCmd_descriptor(); template inline const std::string& SetOpCmd_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function SetOpCmd_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( SetOpCmd_descriptor(), enum_t_value); } inline bool SetOpCmd_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SetOpCmd* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( SetOpCmd_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::min(), SetOpStrategy_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool SetOpStrategy_IsValid(int value); constexpr SetOpStrategy SetOpStrategy_MIN = SET_OP_STRATEGY_UNDEFINED; constexpr SetOpStrategy SetOpStrategy_MAX = SETOP_HASHED; constexpr int SetOpStrategy_ARRAYSIZE = SetOpStrategy_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SetOpStrategy_descriptor(); template inline const std::string& SetOpStrategy_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function SetOpStrategy_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( SetOpStrategy_descriptor(), enum_t_value); } inline bool SetOpStrategy_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SetOpStrategy* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( SetOpStrategy_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::min(), OnConflictAction_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool OnConflictAction_IsValid(int value); constexpr OnConflictAction OnConflictAction_MIN = ON_CONFLICT_ACTION_UNDEFINED; constexpr OnConflictAction OnConflictAction_MAX = ONCONFLICT_UPDATE; constexpr int OnConflictAction_ARRAYSIZE = OnConflictAction_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* OnConflictAction_descriptor(); template inline const std::string& OnConflictAction_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function OnConflictAction_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( OnConflictAction_descriptor(), enum_t_value); } inline bool OnConflictAction_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OnConflictAction* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( OnConflictAction_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::min(), LimitOption_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool LimitOption_IsValid(int value); constexpr LimitOption LimitOption_MIN = LIMIT_OPTION_UNDEFINED; constexpr LimitOption LimitOption_MAX = LIMIT_OPTION_WITH_TIES; constexpr int LimitOption_ARRAYSIZE = LimitOption_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LimitOption_descriptor(); template inline const std::string& LimitOption_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function LimitOption_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( LimitOption_descriptor(), enum_t_value); } inline bool LimitOption_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LimitOption* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( LimitOption_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::min(), LockClauseStrength_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool LockClauseStrength_IsValid(int value); constexpr LockClauseStrength LockClauseStrength_MIN = LOCK_CLAUSE_STRENGTH_UNDEFINED; constexpr LockClauseStrength LockClauseStrength_MAX = LCS_FORUPDATE; constexpr int LockClauseStrength_ARRAYSIZE = LockClauseStrength_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LockClauseStrength_descriptor(); template inline const std::string& LockClauseStrength_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function LockClauseStrength_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( LockClauseStrength_descriptor(), enum_t_value); } inline bool LockClauseStrength_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LockClauseStrength* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( LockClauseStrength_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::min(), LockWaitPolicy_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool LockWaitPolicy_IsValid(int value); constexpr LockWaitPolicy LockWaitPolicy_MIN = LOCK_WAIT_POLICY_UNDEFINED; constexpr LockWaitPolicy LockWaitPolicy_MAX = LockWaitError; constexpr int LockWaitPolicy_ARRAYSIZE = LockWaitPolicy_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LockWaitPolicy_descriptor(); template inline const std::string& LockWaitPolicy_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function LockWaitPolicy_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( LockWaitPolicy_descriptor(), enum_t_value); } inline bool LockWaitPolicy_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LockWaitPolicy* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( LockWaitPolicy_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::min(), LockTupleMode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool LockTupleMode_IsValid(int value); constexpr LockTupleMode LockTupleMode_MIN = LOCK_TUPLE_MODE_UNDEFINED; constexpr LockTupleMode LockTupleMode_MAX = LockTupleExclusive; constexpr int LockTupleMode_ARRAYSIZE = LockTupleMode_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LockTupleMode_descriptor(); template inline const std::string& LockTupleMode_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function LockTupleMode_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( LockTupleMode_descriptor(), enum_t_value); } inline bool LockTupleMode_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LockTupleMode* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( LockTupleMode_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::min(), KeywordKind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool KeywordKind_IsValid(int value); constexpr KeywordKind KeywordKind_MIN = NO_KEYWORD; constexpr KeywordKind KeywordKind_MAX = RESERVED_KEYWORD; constexpr int KeywordKind_ARRAYSIZE = KeywordKind_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* KeywordKind_descriptor(); template inline const std::string& KeywordKind_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function KeywordKind_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( KeywordKind_descriptor(), enum_t_value); } inline bool KeywordKind_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, KeywordKind* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( KeywordKind_descriptor(), name, value); } enum Token : int { NUL = 0, ASCII_37 = 37, ASCII_40 = 40, ASCII_41 = 41, ASCII_42 = 42, ASCII_43 = 43, ASCII_44 = 44, ASCII_45 = 45, ASCII_46 = 46, ASCII_47 = 47, ASCII_58 = 58, ASCII_59 = 59, ASCII_60 = 60, ASCII_61 = 61, ASCII_62 = 62, ASCII_63 = 63, ASCII_91 = 91, ASCII_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, ABSOLUTE_P = 278, ACCESS = 279, ACTION = 280, ADD_P = 281, ADMIN = 282, AFTER = 283, AGGREGATE = 284, ALL = 285, ALSO = 286, ALTER = 287, ALWAYS = 288, ANALYSE = 289, ANALYZE = 290, AND = 291, ANY = 292, ARRAY = 293, AS = 294, ASC = 295, ASENSITIVE = 296, ASSERTION = 297, ASSIGNMENT = 298, ASYMMETRIC = 299, ATOMIC = 300, AT = 301, ATTACH = 302, ATTRIBUTE = 303, AUTHORIZATION = 304, BACKWARD = 305, BEFORE = 306, BEGIN_P = 307, BETWEEN = 308, BIGINT = 309, BINARY = 310, BIT = 311, BOOLEAN_P = 312, BOTH = 313, BREADTH = 314, BY = 315, CACHE = 316, CALL = 317, CALLED = 318, CASCADE = 319, CASCADED = 320, CASE = 321, CAST = 322, CATALOG_P = 323, CHAIN = 324, CHAR_P = 325, CHARACTER = 326, CHARACTERISTICS = 327, CHECK = 328, CHECKPOINT = 329, CLASS = 330, CLOSE = 331, CLUSTER = 332, COALESCE = 333, COLLATE = 334, COLLATION = 335, COLUMN = 336, COLUMNS = 337, COMMENT = 338, COMMENTS = 339, COMMIT = 340, COMMITTED = 341, COMPRESSION = 342, CONCURRENTLY = 343, CONFIGURATION = 344, CONFLICT = 345, CONNECTION = 346, CONSTRAINT = 347, CONSTRAINTS = 348, CONTENT_P = 349, CONTINUE_P = 350, CONVERSION_P = 351, COPY = 352, COST = 353, CREATE = 354, CROSS = 355, CSV = 356, CUBE = 357, CURRENT_P = 358, CURRENT_CATALOG = 359, CURRENT_DATE = 360, CURRENT_ROLE = 361, CURRENT_SCHEMA = 362, CURRENT_TIME = 363, CURRENT_TIMESTAMP = 364, CURRENT_USER = 365, CURSOR = 366, CYCLE = 367, DATA_P = 368, DATABASE = 369, DAY_P = 370, DEALLOCATE = 371, DEC = 372, DECIMAL_P = 373, DECLARE = 374, DEFAULT = 375, DEFAULTS = 376, DEFERRABLE = 377, DEFERRED = 378, DEFINER = 379, DELETE_P = 380, DELIMITER = 381, DELIMITERS = 382, DEPENDS = 383, DEPTH = 384, DESC = 385, DETACH = 386, DICTIONARY = 387, DISABLE_P = 388, DISCARD = 389, DISTINCT = 390, DO = 391, DOCUMENT_P = 392, DOMAIN_P = 393, DOUBLE_P = 394, DROP = 395, EACH = 396, ELSE = 397, ENABLE_P = 398, ENCODING = 399, ENCRYPTED = 400, END_P = 401, ENUM_P = 402, ESCAPE = 403, EVENT = 404, EXCEPT = 405, EXCLUDE = 406, EXCLUDING = 407, EXCLUSIVE = 408, EXECUTE = 409, EXISTS = 410, EXPLAIN = 411, EXPRESSION = 412, EXTENSION = 413, EXTERNAL = 414, EXTRACT = 415, FALSE_P = 416, FAMILY = 417, FETCH = 418, FILTER = 419, FINALIZE = 420, FIRST_P = 421, FLOAT_P = 422, FOLLOWING = 423, FOR = 424, FORCE = 425, FOREIGN = 426, FORWARD = 427, FREEZE = 428, FROM = 429, FULL = 430, FUNCTION = 431, FUNCTIONS = 432, GENERATED = 433, GLOBAL = 434, GRANT = 435, GRANTED = 436, GREATEST = 437, GROUP_P = 438, GROUPING = 439, GROUPS = 440, HANDLER = 441, HAVING = 442, HEADER_P = 443, HOLD = 444, HOUR_P = 445, IDENTITY_P = 446, IF_P = 447, ILIKE = 448, IMMEDIATE = 449, IMMUTABLE = 450, IMPLICIT_P = 451, IMPORT_P = 452, IN_P = 453, INCLUDE = 454, INCLUDING = 455, INCREMENT = 456, INDEX = 457, INDEXES = 458, INHERIT = 459, INHERITS = 460, INITIALLY = 461, INLINE_P = 462, INNER_P = 463, INOUT = 464, INPUT_P = 465, INSENSITIVE = 466, INSERT = 467, INSTEAD = 468, INT_P = 469, INTEGER = 470, INTERSECT = 471, INTERVAL = 472, INTO = 473, INVOKER = 474, IS = 475, ISNULL = 476, ISOLATION = 477, JOIN = 478, KEY = 479, LABEL = 480, LANGUAGE = 481, LARGE_P = 482, LAST_P = 483, LATERAL_P = 484, LEADING = 485, LEAKPROOF = 486, LEAST = 487, LEFT = 488, LEVEL = 489, LIKE = 490, LIMIT = 491, LISTEN = 492, LOAD = 493, LOCAL = 494, LOCALTIME = 495, LOCALTIMESTAMP = 496, LOCATION = 497, LOCK_P = 498, LOCKED = 499, LOGGED = 500, MAPPING = 501, MATCH = 502, MATCHED = 503, MATERIALIZED = 504, MAXVALUE = 505, MERGE = 506, METHOD = 507, MINUTE_P = 508, MINVALUE = 509, MODE = 510, MONTH_P = 511, MOVE = 512, NAME_P = 513, NAMES = 514, NATIONAL = 515, NATURAL = 516, NCHAR = 517, NEW = 518, NEXT = 519, NFC = 520, NFD = 521, NFKC = 522, NFKD = 523, NO = 524, NONE = 525, NORMALIZE = 526, NORMALIZED = 527, NOT = 528, NOTHING = 529, NOTIFY = 530, NOTNULL = 531, NOWAIT = 532, NULL_P = 533, NULLIF = 534, NULLS_P = 535, NUMERIC = 536, OBJECT_P = 537, OF = 538, OFF = 539, OFFSET = 540, OIDS = 541, OLD = 542, ON = 543, ONLY = 544, OPERATOR = 545, OPTION = 546, OPTIONS = 547, OR = 548, ORDER = 549, ORDINALITY = 550, OTHERS = 551, OUT_P = 552, OUTER_P = 553, OVER = 554, OVERLAPS = 555, OVERLAY = 556, OVERRIDING = 557, OWNED = 558, OWNER = 559, PARALLEL = 560, PARAMETER = 561, PARSER = 562, PARTIAL = 563, PARTITION = 564, PASSING = 565, PASSWORD = 566, PLACING = 567, PLANS = 568, POLICY = 569, POSITION = 570, PRECEDING = 571, PRECISION = 572, PRESERVE = 573, PREPARE = 574, PREPARED = 575, PRIMARY = 576, PRIOR = 577, PRIVILEGES = 578, PROCEDURAL = 579, PROCEDURE = 580, PROCEDURES = 581, PROGRAM = 582, PUBLICATION = 583, QUOTE = 584, RANGE = 585, READ = 586, REAL = 587, REASSIGN = 588, RECHECK = 589, RECURSIVE = 590, REF_P = 591, REFERENCES = 592, REFERENCING = 593, REFRESH = 594, REINDEX = 595, RELATIVE_P = 596, RELEASE = 597, RENAME = 598, REPEATABLE = 599, REPLACE = 600, REPLICA = 601, RESET = 602, RESTART = 603, RESTRICT = 604, RETURN = 605, RETURNING = 606, RETURNS = 607, REVOKE = 608, RIGHT = 609, ROLE = 610, ROLLBACK = 611, ROLLUP = 612, ROUTINE = 613, ROUTINES = 614, ROW = 615, ROWS = 616, RULE = 617, SAVEPOINT = 618, SCHEMA = 619, SCHEMAS = 620, SCROLL = 621, SEARCH = 622, SECOND_P = 623, SECURITY = 624, SELECT = 625, SEQUENCE = 626, SEQUENCES = 627, SERIALIZABLE = 628, SERVER = 629, SESSION = 630, SESSION_USER = 631, SET = 632, SETS = 633, SETOF = 634, SHARE = 635, SHOW = 636, SIMILAR = 637, SIMPLE = 638, SKIP = 639, SMALLINT = 640, SNAPSHOT = 641, SOME = 642, SQL_P = 643, STABLE = 644, STANDALONE_P = 645, START = 646, STATEMENT = 647, STATISTICS = 648, STDIN = 649, STDOUT = 650, STORAGE = 651, STORED = 652, STRICT_P = 653, STRIP_P = 654, SUBSCRIPTION = 655, SUBSTRING = 656, SUPPORT = 657, SYMMETRIC = 658, SYSID = 659, SYSTEM_P = 660, TABLE = 661, TABLES = 662, TABLESAMPLE = 663, TABLESPACE = 664, TEMP = 665, TEMPLATE = 666, TEMPORARY = 667, TEXT_P = 668, THEN = 669, TIES = 670, TIME = 671, TIMESTAMP = 672, TO = 673, TRAILING = 674, TRANSACTION = 675, TRANSFORM = 676, TREAT = 677, TRIGGER = 678, TRIM = 679, TRUE_P = 680, TRUNCATE = 681, TRUSTED = 682, TYPE_P = 683, TYPES_P = 684, UESCAPE = 685, UNBOUNDED = 686, UNCOMMITTED = 687, UNENCRYPTED = 688, UNION = 689, UNIQUE = 690, UNKNOWN = 691, UNLISTEN = 692, UNLOGGED = 693, UNTIL = 694, UPDATE = 695, USER = 696, USING = 697, VACUUM = 698, VALID = 699, VALIDATE = 700, VALIDATOR = 701, VALUE_P = 702, VALUES = 703, VARCHAR = 704, VARIADIC = 705, VARYING = 706, VERBOSE = 707, VERSION_P = 708, VIEW = 709, VIEWS = 710, VOLATILE = 711, WHEN = 712, WHERE = 713, WHITESPACE_P = 714, WINDOW = 715, WITH = 716, WITHIN = 717, WITHOUT = 718, WORK = 719, WRAPPER = 720, WRITE = 721, XML_P = 722, XMLATTRIBUTES = 723, XMLCONCAT = 724, XMLELEMENT = 725, XMLEXISTS = 726, XMLFOREST = 727, XMLNAMESPACES = 728, XMLPARSE = 729, XMLPI = 730, XMLROOT = 731, XMLSERIALIZE = 732, XMLTABLE = 733, YEAR_P = 734, YES_P = 735, ZONE = 736, NOT_LA = 737, NULLS_LA = 738, WITH_LA = 739, MODE_TYPE_NAME = 740, MODE_PLPGSQL_EXPR = 741, MODE_PLPGSQL_ASSIGN1 = 742, MODE_PLPGSQL_ASSIGN2 = 743, MODE_PLPGSQL_ASSIGN3 = 744, UMINUS = 745, Token_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), Token_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool Token_IsValid(int value); constexpr Token Token_MIN = NUL; constexpr Token Token_MAX = UMINUS; constexpr int Token_ARRAYSIZE = Token_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Token_descriptor(); template inline const std::string& Token_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function Token_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( Token_descriptor(), enum_t_value); } inline bool Token_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Token* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( Token_descriptor(), name, value); } // =================================================================== class ParseResult final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ParseResult) */ { public: inline ParseResult() : ParseResult(nullptr) {} ~ParseResult() override; explicit PROTOBUF_CONSTEXPR ParseResult(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ParseResult(const ParseResult& from); ParseResult(ParseResult&& from) noexcept : ParseResult() { *this = ::std::move(from); } inline ParseResult& operator=(const ParseResult& from) { CopyFrom(from); return *this; } inline ParseResult& operator=(ParseResult&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ParseResult* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ParseResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ParseResult& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ParseResult& from) { ParseResult::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ParseResult* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.ParseResult"; } protected: explicit ParseResult(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::RawStmt >* mutable_stmts(); private: const ::pg_query::RawStmt& _internal_stmts(int index) const; ::pg_query::RawStmt* _internal_add_stmts(); public: const ::pg_query::RawStmt& stmts(int index) const; ::pg_query::RawStmt* add_stmts(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::RawStmt >& stmts() const; // int32 version = 1; void clear_version(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::RawStmt > stmts_; int32_t version_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class ScanResult final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ScanResult) */ { public: inline ScanResult() : ScanResult(nullptr) {} ~ScanResult() override; explicit PROTOBUF_CONSTEXPR ScanResult(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ScanResult(const ScanResult& from); ScanResult(ScanResult&& from) noexcept : ScanResult() { *this = ::std::move(from); } inline ScanResult& operator=(const ScanResult& from) { CopyFrom(from); return *this; } inline ScanResult& operator=(ScanResult&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ScanResult* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ScanResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ScanResult& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ScanResult& from) { ScanResult::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ScanResult* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.ScanResult"; } protected: explicit ScanResult(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::ScanToken >* mutable_tokens(); private: const ::pg_query::ScanToken& _internal_tokens(int index) const; ::pg_query::ScanToken* _internal_add_tokens(); public: const ::pg_query::ScanToken& tokens(int index) const; ::pg_query::ScanToken* add_tokens(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::ScanToken >& tokens() const; // int32 version = 1; void clear_version(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::ScanToken > tokens_; int32_t version_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class Node final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.Node) */ { public: inline Node() : Node(nullptr) {} ~Node() override; explicit PROTOBUF_CONSTEXPR Node(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); Node(const Node& from); Node(Node&& from) noexcept : Node() { *this = ::std::move(from); } inline Node& operator=(const Node& from) { CopyFrom(from); return *this; } inline Node& operator=(Node&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const Node& default_instance() { return *internal_default_instance(); } enum NodeCase { kAlias = 1, kRangeVar = 2, kTableFunc = 3, kVar = 4, kParam = 5, kAggref = 6, kGroupingFunc = 7, kWindowFunc = 8, kSubscriptingRef = 9, kFuncExpr = 10, kNamedArgExpr = 11, kOpExpr = 12, kDistinctExpr = 13, kNullIfExpr = 14, kScalarArrayOpExpr = 15, kBoolExpr = 16, kSubLink = 17, kSubPlan = 18, kAlternativeSubPlan = 19, kFieldSelect = 20, kFieldStore = 21, kRelabelType = 22, kCoerceViaIo = 23, kArrayCoerceExpr = 24, kConvertRowtypeExpr = 25, kCollateExpr = 26, kCaseExpr = 27, kCaseWhen = 28, kCaseTestExpr = 29, kArrayExpr = 30, kRowExpr = 31, kRowCompareExpr = 32, kCoalesceExpr = 33, kMinMaxExpr = 34, kSqlvalueFunction = 35, kXmlExpr = 36, kNullTest = 37, kBooleanTest = 38, kCoerceToDomain = 39, kCoerceToDomainValue = 40, kSetToDefault = 41, kCurrentOfExpr = 42, kNextValueExpr = 43, kInferenceElem = 44, kTargetEntry = 45, kRangeTblRef = 46, kJoinExpr = 47, kFromExpr = 48, kOnConflictExpr = 49, kIntoClause = 50, kMergeAction = 51, kRawStmt = 52, kQuery = 53, kInsertStmt = 54, kDeleteStmt = 55, kUpdateStmt = 56, kMergeStmt = 57, kSelectStmt = 58, kReturnStmt = 59, kPlassignStmt = 60, kAlterTableStmt = 61, kAlterTableCmd = 62, kAlterDomainStmt = 63, kSetOperationStmt = 64, kGrantStmt = 65, kGrantRoleStmt = 66, kAlterDefaultPrivilegesStmt = 67, kClosePortalStmt = 68, kClusterStmt = 69, kCopyStmt = 70, kCreateStmt = 71, kDefineStmt = 72, kDropStmt = 73, kTruncateStmt = 74, kCommentStmt = 75, kFetchStmt = 76, kIndexStmt = 77, kCreateFunctionStmt = 78, kAlterFunctionStmt = 79, kDoStmt = 80, kRenameStmt = 81, kRuleStmt = 82, kNotifyStmt = 83, kListenStmt = 84, kUnlistenStmt = 85, kTransactionStmt = 86, kViewStmt = 87, kLoadStmt = 88, kCreateDomainStmt = 89, kCreatedbStmt = 90, kDropdbStmt = 91, kVacuumStmt = 92, kExplainStmt = 93, kCreateTableAsStmt = 94, kCreateSeqStmt = 95, kAlterSeqStmt = 96, kVariableSetStmt = 97, kVariableShowStmt = 98, kDiscardStmt = 99, kCreateTrigStmt = 100, kCreatePlangStmt = 101, kCreateRoleStmt = 102, kAlterRoleStmt = 103, kDropRoleStmt = 104, kLockStmt = 105, kConstraintsSetStmt = 106, kReindexStmt = 107, kCheckPointStmt = 108, kCreateSchemaStmt = 109, kAlterDatabaseStmt = 110, kAlterDatabaseRefreshCollStmt = 111, kAlterDatabaseSetStmt = 112, kAlterRoleSetStmt = 113, kCreateConversionStmt = 114, kCreateCastStmt = 115, kCreateOpClassStmt = 116, kCreateOpFamilyStmt = 117, kAlterOpFamilyStmt = 118, kPrepareStmt = 119, kExecuteStmt = 120, kDeallocateStmt = 121, kDeclareCursorStmt = 122, kCreateTableSpaceStmt = 123, kDropTableSpaceStmt = 124, kAlterObjectDependsStmt = 125, kAlterObjectSchemaStmt = 126, kAlterOwnerStmt = 127, kAlterOperatorStmt = 128, kAlterTypeStmt = 129, kDropOwnedStmt = 130, kReassignOwnedStmt = 131, kCompositeTypeStmt = 132, kCreateEnumStmt = 133, kCreateRangeStmt = 134, kAlterEnumStmt = 135, kAlterTsdictionaryStmt = 136, kAlterTsconfigurationStmt = 137, kCreateFdwStmt = 138, kAlterFdwStmt = 139, kCreateForeignServerStmt = 140, kAlterForeignServerStmt = 141, kCreateUserMappingStmt = 142, kAlterUserMappingStmt = 143, kDropUserMappingStmt = 144, kAlterTableSpaceOptionsStmt = 145, kAlterTableMoveAllStmt = 146, kSecLabelStmt = 147, kCreateForeignTableStmt = 148, kImportForeignSchemaStmt = 149, kCreateExtensionStmt = 150, kAlterExtensionStmt = 151, kAlterExtensionContentsStmt = 152, kCreateEventTrigStmt = 153, kAlterEventTrigStmt = 154, kRefreshMatViewStmt = 155, kReplicaIdentityStmt = 156, kAlterSystemStmt = 157, kCreatePolicyStmt = 158, kAlterPolicyStmt = 159, kCreateTransformStmt = 160, kCreateAmStmt = 161, kCreatePublicationStmt = 162, kAlterPublicationStmt = 163, kCreateSubscriptionStmt = 164, kAlterSubscriptionStmt = 165, kDropSubscriptionStmt = 166, kCreateStatsStmt = 167, kAlterCollationStmt = 168, kCallStmt = 169, kAlterStatsStmt = 170, kAExpr = 171, kColumnRef = 172, kParamRef = 173, kFuncCall = 174, kAStar = 175, kAIndices = 176, kAIndirection = 177, kAArrayExpr = 178, kResTarget = 179, kMultiAssignRef = 180, kTypeCast = 181, kCollateClause = 182, kSortBy = 183, kWindowDef = 184, kRangeSubselect = 185, kRangeFunction = 186, kRangeTableSample = 187, kRangeTableFunc = 188, kRangeTableFuncCol = 189, kTypeName = 190, kColumnDef = 191, kIndexElem = 192, kStatsElem = 193, kConstraint = 194, kDefElem = 195, kRangeTblEntry = 196, kRangeTblFunction = 197, kTableSampleClause = 198, kWithCheckOption = 199, kSortGroupClause = 200, kGroupingSet = 201, kWindowClause = 202, kObjectWithArgs = 203, kAccessPriv = 204, kCreateOpClassItem = 205, kTableLikeClause = 206, kFunctionParameter = 207, kLockingClause = 208, kRowMarkClause = 209, kXmlSerialize = 210, kWithClause = 211, kInferClause = 212, kOnConflictClause = 213, kCtesearchClause = 214, kCtecycleClause = 215, kCommonTableExpr = 216, kMergeWhenClause = 217, kRoleSpec = 218, kTriggerTransition = 219, kPartitionElem = 220, kPartitionSpec = 221, kPartitionBoundSpec = 222, kPartitionRangeDatum = 223, kPartitionCmd = 224, kVacuumRelation = 225, kPublicationObjSpec = 226, kPublicationTable = 227, kInlineCodeBlock = 228, kCallContext = 229, kInteger = 230, kFloat = 231, kBoolean = 232, kString = 233, kBitString = 234, kList = 235, kIntList = 236, kOidList = 237, kAConst = 238, NODE_NOT_SET = 0, }; static inline const Node* internal_default_instance() { return reinterpret_cast( &_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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(Node* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- Node* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Node& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const Node& from) { Node::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Node* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.Node"; } protected: explicit Node(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kAliasFieldNumber = 1, kRangeVarFieldNumber = 2, kTableFuncFieldNumber = 3, kVarFieldNumber = 4, kParamFieldNumber = 5, kAggrefFieldNumber = 6, kGroupingFuncFieldNumber = 7, kWindowFuncFieldNumber = 8, kSubscriptingRefFieldNumber = 9, kFuncExprFieldNumber = 10, kNamedArgExprFieldNumber = 11, kOpExprFieldNumber = 12, kDistinctExprFieldNumber = 13, kNullIfExprFieldNumber = 14, kScalarArrayOpExprFieldNumber = 15, kBoolExprFieldNumber = 16, kSubLinkFieldNumber = 17, kSubPlanFieldNumber = 18, kAlternativeSubPlanFieldNumber = 19, kFieldSelectFieldNumber = 20, kFieldStoreFieldNumber = 21, kRelabelTypeFieldNumber = 22, kCoerceViaIoFieldNumber = 23, kArrayCoerceExprFieldNumber = 24, kConvertRowtypeExprFieldNumber = 25, kCollateExprFieldNumber = 26, kCaseExprFieldNumber = 27, kCaseWhenFieldNumber = 28, kCaseTestExprFieldNumber = 29, kArrayExprFieldNumber = 30, kRowExprFieldNumber = 31, kRowCompareExprFieldNumber = 32, kCoalesceExprFieldNumber = 33, kMinMaxExprFieldNumber = 34, kSqlvalueFunctionFieldNumber = 35, kXmlExprFieldNumber = 36, kNullTestFieldNumber = 37, kBooleanTestFieldNumber = 38, kCoerceToDomainFieldNumber = 39, kCoerceToDomainValueFieldNumber = 40, kSetToDefaultFieldNumber = 41, kCurrentOfExprFieldNumber = 42, kNextValueExprFieldNumber = 43, kInferenceElemFieldNumber = 44, kTargetEntryFieldNumber = 45, kRangeTblRefFieldNumber = 46, kJoinExprFieldNumber = 47, kFromExprFieldNumber = 48, kOnConflictExprFieldNumber = 49, kIntoClauseFieldNumber = 50, kMergeActionFieldNumber = 51, kRawStmtFieldNumber = 52, kQueryFieldNumber = 53, kInsertStmtFieldNumber = 54, kDeleteStmtFieldNumber = 55, kUpdateStmtFieldNumber = 56, kMergeStmtFieldNumber = 57, kSelectStmtFieldNumber = 58, kReturnStmtFieldNumber = 59, kPlassignStmtFieldNumber = 60, kAlterTableStmtFieldNumber = 61, kAlterTableCmdFieldNumber = 62, kAlterDomainStmtFieldNumber = 63, kSetOperationStmtFieldNumber = 64, kGrantStmtFieldNumber = 65, kGrantRoleStmtFieldNumber = 66, kAlterDefaultPrivilegesStmtFieldNumber = 67, kClosePortalStmtFieldNumber = 68, kClusterStmtFieldNumber = 69, kCopyStmtFieldNumber = 70, kCreateStmtFieldNumber = 71, kDefineStmtFieldNumber = 72, kDropStmtFieldNumber = 73, kTruncateStmtFieldNumber = 74, kCommentStmtFieldNumber = 75, kFetchStmtFieldNumber = 76, kIndexStmtFieldNumber = 77, kCreateFunctionStmtFieldNumber = 78, kAlterFunctionStmtFieldNumber = 79, kDoStmtFieldNumber = 80, kRenameStmtFieldNumber = 81, kRuleStmtFieldNumber = 82, kNotifyStmtFieldNumber = 83, kListenStmtFieldNumber = 84, kUnlistenStmtFieldNumber = 85, kTransactionStmtFieldNumber = 86, kViewStmtFieldNumber = 87, kLoadStmtFieldNumber = 88, kCreateDomainStmtFieldNumber = 89, kCreatedbStmtFieldNumber = 90, kDropdbStmtFieldNumber = 91, kVacuumStmtFieldNumber = 92, kExplainStmtFieldNumber = 93, kCreateTableAsStmtFieldNumber = 94, kCreateSeqStmtFieldNumber = 95, kAlterSeqStmtFieldNumber = 96, kVariableSetStmtFieldNumber = 97, kVariableShowStmtFieldNumber = 98, kDiscardStmtFieldNumber = 99, kCreateTrigStmtFieldNumber = 100, kCreatePlangStmtFieldNumber = 101, kCreateRoleStmtFieldNumber = 102, kAlterRoleStmtFieldNumber = 103, kDropRoleStmtFieldNumber = 104, kLockStmtFieldNumber = 105, kConstraintsSetStmtFieldNumber = 106, kReindexStmtFieldNumber = 107, kCheckPointStmtFieldNumber = 108, kCreateSchemaStmtFieldNumber = 109, kAlterDatabaseStmtFieldNumber = 110, kAlterDatabaseRefreshCollStmtFieldNumber = 111, kAlterDatabaseSetStmtFieldNumber = 112, kAlterRoleSetStmtFieldNumber = 113, kCreateConversionStmtFieldNumber = 114, kCreateCastStmtFieldNumber = 115, kCreateOpClassStmtFieldNumber = 116, kCreateOpFamilyStmtFieldNumber = 117, kAlterOpFamilyStmtFieldNumber = 118, kPrepareStmtFieldNumber = 119, kExecuteStmtFieldNumber = 120, kDeallocateStmtFieldNumber = 121, kDeclareCursorStmtFieldNumber = 122, kCreateTableSpaceStmtFieldNumber = 123, kDropTableSpaceStmtFieldNumber = 124, kAlterObjectDependsStmtFieldNumber = 125, kAlterObjectSchemaStmtFieldNumber = 126, kAlterOwnerStmtFieldNumber = 127, kAlterOperatorStmtFieldNumber = 128, kAlterTypeStmtFieldNumber = 129, kDropOwnedStmtFieldNumber = 130, kReassignOwnedStmtFieldNumber = 131, kCompositeTypeStmtFieldNumber = 132, kCreateEnumStmtFieldNumber = 133, kCreateRangeStmtFieldNumber = 134, kAlterEnumStmtFieldNumber = 135, kAlterTsdictionaryStmtFieldNumber = 136, kAlterTsconfigurationStmtFieldNumber = 137, kCreateFdwStmtFieldNumber = 138, kAlterFdwStmtFieldNumber = 139, kCreateForeignServerStmtFieldNumber = 140, kAlterForeignServerStmtFieldNumber = 141, kCreateUserMappingStmtFieldNumber = 142, kAlterUserMappingStmtFieldNumber = 143, kDropUserMappingStmtFieldNumber = 144, kAlterTableSpaceOptionsStmtFieldNumber = 145, kAlterTableMoveAllStmtFieldNumber = 146, kSecLabelStmtFieldNumber = 147, kCreateForeignTableStmtFieldNumber = 148, kImportForeignSchemaStmtFieldNumber = 149, kCreateExtensionStmtFieldNumber = 150, kAlterExtensionStmtFieldNumber = 151, kAlterExtensionContentsStmtFieldNumber = 152, kCreateEventTrigStmtFieldNumber = 153, kAlterEventTrigStmtFieldNumber = 154, kRefreshMatViewStmtFieldNumber = 155, kReplicaIdentityStmtFieldNumber = 156, kAlterSystemStmtFieldNumber = 157, kCreatePolicyStmtFieldNumber = 158, kAlterPolicyStmtFieldNumber = 159, kCreateTransformStmtFieldNumber = 160, kCreateAmStmtFieldNumber = 161, kCreatePublicationStmtFieldNumber = 162, kAlterPublicationStmtFieldNumber = 163, kCreateSubscriptionStmtFieldNumber = 164, kAlterSubscriptionStmtFieldNumber = 165, kDropSubscriptionStmtFieldNumber = 166, kCreateStatsStmtFieldNumber = 167, kAlterCollationStmtFieldNumber = 168, kCallStmtFieldNumber = 169, kAlterStatsStmtFieldNumber = 170, kAExprFieldNumber = 171, kColumnRefFieldNumber = 172, kParamRefFieldNumber = 173, kFuncCallFieldNumber = 174, kAStarFieldNumber = 175, kAIndicesFieldNumber = 176, kAIndirectionFieldNumber = 177, kAArrayExprFieldNumber = 178, kResTargetFieldNumber = 179, kMultiAssignRefFieldNumber = 180, kTypeCastFieldNumber = 181, kCollateClauseFieldNumber = 182, kSortByFieldNumber = 183, kWindowDefFieldNumber = 184, kRangeSubselectFieldNumber = 185, kRangeFunctionFieldNumber = 186, kRangeTableSampleFieldNumber = 187, kRangeTableFuncFieldNumber = 188, kRangeTableFuncColFieldNumber = 189, kTypeNameFieldNumber = 190, kColumnDefFieldNumber = 191, kIndexElemFieldNumber = 192, kStatsElemFieldNumber = 193, kConstraintFieldNumber = 194, kDefElemFieldNumber = 195, kRangeTblEntryFieldNumber = 196, kRangeTblFunctionFieldNumber = 197, kTableSampleClauseFieldNumber = 198, kWithCheckOptionFieldNumber = 199, kSortGroupClauseFieldNumber = 200, kGroupingSetFieldNumber = 201, kWindowClauseFieldNumber = 202, kObjectWithArgsFieldNumber = 203, kAccessPrivFieldNumber = 204, kCreateOpClassItemFieldNumber = 205, kTableLikeClauseFieldNumber = 206, kFunctionParameterFieldNumber = 207, kLockingClauseFieldNumber = 208, kRowMarkClauseFieldNumber = 209, kXmlSerializeFieldNumber = 210, kWithClauseFieldNumber = 211, kInferClauseFieldNumber = 212, kOnConflictClauseFieldNumber = 213, kCtesearchClauseFieldNumber = 214, kCtecycleClauseFieldNumber = 215, kCommonTableExprFieldNumber = 216, kMergeWhenClauseFieldNumber = 217, kRoleSpecFieldNumber = 218, kTriggerTransitionFieldNumber = 219, kPartitionElemFieldNumber = 220, kPartitionSpecFieldNumber = 221, kPartitionBoundSpecFieldNumber = 222, kPartitionRangeDatumFieldNumber = 223, kPartitionCmdFieldNumber = 224, kVacuumRelationFieldNumber = 225, kPublicationObjSpecFieldNumber = 226, kPublicationTableFieldNumber = 227, kInlineCodeBlockFieldNumber = 228, kCallContextFieldNumber = 229, kIntegerFieldNumber = 230, kFloatFieldNumber = 231, kBooleanFieldNumber = 232, kStringFieldNumber = 233, kBitStringFieldNumber = 234, kListFieldNumber = 235, kIntListFieldNumber = 236, kOidListFieldNumber = 237, kAConstFieldNumber = 238, }; // .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* alias); private: const ::pg_query::Alias& _internal_alias() const; ::pg_query::Alias* _internal_mutable_alias(); public: void unsafe_arena_set_allocated_alias( ::pg_query::Alias* alias); ::pg_query::Alias* unsafe_arena_release_alias(); // .pg_query.RangeVar range_var = 2 [json_name = "RangeVar"]; bool has_range_var() const; private: bool _internal_has_range_var() const; public: void clear_range_var(); const ::pg_query::RangeVar& range_var() const; PROTOBUF_NODISCARD ::pg_query::RangeVar* release_range_var(); ::pg_query::RangeVar* mutable_range_var(); void set_allocated_range_var(::pg_query::RangeVar* range_var); private: const ::pg_query::RangeVar& _internal_range_var() const; ::pg_query::RangeVar* _internal_mutable_range_var(); public: void unsafe_arena_set_allocated_range_var( ::pg_query::RangeVar* range_var); ::pg_query::RangeVar* unsafe_arena_release_range_var(); // .pg_query.TableFunc table_func = 3 [json_name = "TableFunc"]; bool has_table_func() const; private: bool _internal_has_table_func() const; public: void clear_table_func(); const ::pg_query::TableFunc& table_func() const; PROTOBUF_NODISCARD ::pg_query::TableFunc* release_table_func(); ::pg_query::TableFunc* mutable_table_func(); void set_allocated_table_func(::pg_query::TableFunc* table_func); private: const ::pg_query::TableFunc& _internal_table_func() const; ::pg_query::TableFunc* _internal_mutable_table_func(); public: void unsafe_arena_set_allocated_table_func( ::pg_query::TableFunc* table_func); ::pg_query::TableFunc* unsafe_arena_release_table_func(); // .pg_query.Var var = 4 [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* var); private: const ::pg_query::Var& _internal_var() const; ::pg_query::Var* _internal_mutable_var(); public: void unsafe_arena_set_allocated_var( ::pg_query::Var* var); ::pg_query::Var* unsafe_arena_release_var(); // .pg_query.Param param = 5 [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* param); private: const ::pg_query::Param& _internal_param() const; ::pg_query::Param* _internal_mutable_param(); public: void unsafe_arena_set_allocated_param( ::pg_query::Param* param); ::pg_query::Param* unsafe_arena_release_param(); // .pg_query.Aggref aggref = 6 [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* aggref); private: const ::pg_query::Aggref& _internal_aggref() const; ::pg_query::Aggref* _internal_mutable_aggref(); public: void unsafe_arena_set_allocated_aggref( ::pg_query::Aggref* aggref); ::pg_query::Aggref* unsafe_arena_release_aggref(); // .pg_query.GroupingFunc grouping_func = 7 [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* grouping_func); private: const ::pg_query::GroupingFunc& _internal_grouping_func() const; ::pg_query::GroupingFunc* _internal_mutable_grouping_func(); public: void unsafe_arena_set_allocated_grouping_func( ::pg_query::GroupingFunc* grouping_func); ::pg_query::GroupingFunc* unsafe_arena_release_grouping_func(); // .pg_query.WindowFunc window_func = 8 [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* window_func); private: const ::pg_query::WindowFunc& _internal_window_func() const; ::pg_query::WindowFunc* _internal_mutable_window_func(); public: void unsafe_arena_set_allocated_window_func( ::pg_query::WindowFunc* window_func); ::pg_query::WindowFunc* unsafe_arena_release_window_func(); // .pg_query.SubscriptingRef subscripting_ref = 9 [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* subscripting_ref); private: const ::pg_query::SubscriptingRef& _internal_subscripting_ref() const; ::pg_query::SubscriptingRef* _internal_mutable_subscripting_ref(); public: void unsafe_arena_set_allocated_subscripting_ref( ::pg_query::SubscriptingRef* subscripting_ref); ::pg_query::SubscriptingRef* unsafe_arena_release_subscripting_ref(); // .pg_query.FuncExpr func_expr = 10 [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* func_expr); private: const ::pg_query::FuncExpr& _internal_func_expr() const; ::pg_query::FuncExpr* _internal_mutable_func_expr(); public: void unsafe_arena_set_allocated_func_expr( ::pg_query::FuncExpr* func_expr); ::pg_query::FuncExpr* unsafe_arena_release_func_expr(); // .pg_query.NamedArgExpr named_arg_expr = 11 [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* named_arg_expr); private: const ::pg_query::NamedArgExpr& _internal_named_arg_expr() const; ::pg_query::NamedArgExpr* _internal_mutable_named_arg_expr(); public: void unsafe_arena_set_allocated_named_arg_expr( ::pg_query::NamedArgExpr* named_arg_expr); ::pg_query::NamedArgExpr* unsafe_arena_release_named_arg_expr(); // .pg_query.OpExpr op_expr = 12 [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* op_expr); private: const ::pg_query::OpExpr& _internal_op_expr() const; ::pg_query::OpExpr* _internal_mutable_op_expr(); public: void unsafe_arena_set_allocated_op_expr( ::pg_query::OpExpr* op_expr); ::pg_query::OpExpr* unsafe_arena_release_op_expr(); // .pg_query.DistinctExpr distinct_expr = 13 [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* distinct_expr); private: const ::pg_query::DistinctExpr& _internal_distinct_expr() const; ::pg_query::DistinctExpr* _internal_mutable_distinct_expr(); public: void unsafe_arena_set_allocated_distinct_expr( ::pg_query::DistinctExpr* distinct_expr); ::pg_query::DistinctExpr* unsafe_arena_release_distinct_expr(); // .pg_query.NullIfExpr null_if_expr = 14 [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* null_if_expr); private: const ::pg_query::NullIfExpr& _internal_null_if_expr() const; ::pg_query::NullIfExpr* _internal_mutable_null_if_expr(); public: void unsafe_arena_set_allocated_null_if_expr( ::pg_query::NullIfExpr* null_if_expr); ::pg_query::NullIfExpr* unsafe_arena_release_null_if_expr(); // .pg_query.ScalarArrayOpExpr scalar_array_op_expr = 15 [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* scalar_array_op_expr); private: const ::pg_query::ScalarArrayOpExpr& _internal_scalar_array_op_expr() const; ::pg_query::ScalarArrayOpExpr* _internal_mutable_scalar_array_op_expr(); public: void unsafe_arena_set_allocated_scalar_array_op_expr( ::pg_query::ScalarArrayOpExpr* scalar_array_op_expr); ::pg_query::ScalarArrayOpExpr* unsafe_arena_release_scalar_array_op_expr(); // .pg_query.BoolExpr bool_expr = 16 [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* bool_expr); private: const ::pg_query::BoolExpr& _internal_bool_expr() const; ::pg_query::BoolExpr* _internal_mutable_bool_expr(); public: void unsafe_arena_set_allocated_bool_expr( ::pg_query::BoolExpr* bool_expr); ::pg_query::BoolExpr* unsafe_arena_release_bool_expr(); // .pg_query.SubLink sub_link = 17 [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* sub_link); private: const ::pg_query::SubLink& _internal_sub_link() const; ::pg_query::SubLink* _internal_mutable_sub_link(); public: void unsafe_arena_set_allocated_sub_link( ::pg_query::SubLink* sub_link); ::pg_query::SubLink* unsafe_arena_release_sub_link(); // .pg_query.SubPlan sub_plan = 18 [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* sub_plan); private: const ::pg_query::SubPlan& _internal_sub_plan() const; ::pg_query::SubPlan* _internal_mutable_sub_plan(); public: void unsafe_arena_set_allocated_sub_plan( ::pg_query::SubPlan* sub_plan); ::pg_query::SubPlan* unsafe_arena_release_sub_plan(); // .pg_query.AlternativeSubPlan alternative_sub_plan = 19 [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* alternative_sub_plan); private: const ::pg_query::AlternativeSubPlan& _internal_alternative_sub_plan() const; ::pg_query::AlternativeSubPlan* _internal_mutable_alternative_sub_plan(); public: void unsafe_arena_set_allocated_alternative_sub_plan( ::pg_query::AlternativeSubPlan* alternative_sub_plan); ::pg_query::AlternativeSubPlan* unsafe_arena_release_alternative_sub_plan(); // .pg_query.FieldSelect field_select = 20 [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* field_select); private: const ::pg_query::FieldSelect& _internal_field_select() const; ::pg_query::FieldSelect* _internal_mutable_field_select(); public: void unsafe_arena_set_allocated_field_select( ::pg_query::FieldSelect* field_select); ::pg_query::FieldSelect* unsafe_arena_release_field_select(); // .pg_query.FieldStore field_store = 21 [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* field_store); private: const ::pg_query::FieldStore& _internal_field_store() const; ::pg_query::FieldStore* _internal_mutable_field_store(); public: void unsafe_arena_set_allocated_field_store( ::pg_query::FieldStore* field_store); ::pg_query::FieldStore* unsafe_arena_release_field_store(); // .pg_query.RelabelType relabel_type = 22 [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* relabel_type); private: const ::pg_query::RelabelType& _internal_relabel_type() const; ::pg_query::RelabelType* _internal_mutable_relabel_type(); public: void unsafe_arena_set_allocated_relabel_type( ::pg_query::RelabelType* relabel_type); ::pg_query::RelabelType* unsafe_arena_release_relabel_type(); // .pg_query.CoerceViaIO coerce_via_io = 23 [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* coerce_via_io); private: const ::pg_query::CoerceViaIO& _internal_coerce_via_io() const; ::pg_query::CoerceViaIO* _internal_mutable_coerce_via_io(); public: void unsafe_arena_set_allocated_coerce_via_io( ::pg_query::CoerceViaIO* coerce_via_io); ::pg_query::CoerceViaIO* unsafe_arena_release_coerce_via_io(); // .pg_query.ArrayCoerceExpr array_coerce_expr = 24 [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* array_coerce_expr); private: const ::pg_query::ArrayCoerceExpr& _internal_array_coerce_expr() const; ::pg_query::ArrayCoerceExpr* _internal_mutable_array_coerce_expr(); public: void unsafe_arena_set_allocated_array_coerce_expr( ::pg_query::ArrayCoerceExpr* array_coerce_expr); ::pg_query::ArrayCoerceExpr* unsafe_arena_release_array_coerce_expr(); // .pg_query.ConvertRowtypeExpr convert_rowtype_expr = 25 [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* convert_rowtype_expr); private: const ::pg_query::ConvertRowtypeExpr& _internal_convert_rowtype_expr() const; ::pg_query::ConvertRowtypeExpr* _internal_mutable_convert_rowtype_expr(); public: void unsafe_arena_set_allocated_convert_rowtype_expr( ::pg_query::ConvertRowtypeExpr* convert_rowtype_expr); ::pg_query::ConvertRowtypeExpr* unsafe_arena_release_convert_rowtype_expr(); // .pg_query.CollateExpr collate_expr = 26 [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* collate_expr); private: const ::pg_query::CollateExpr& _internal_collate_expr() const; ::pg_query::CollateExpr* _internal_mutable_collate_expr(); public: void unsafe_arena_set_allocated_collate_expr( ::pg_query::CollateExpr* collate_expr); ::pg_query::CollateExpr* unsafe_arena_release_collate_expr(); // .pg_query.CaseExpr case_expr = 27 [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* case_expr); private: const ::pg_query::CaseExpr& _internal_case_expr() const; ::pg_query::CaseExpr* _internal_mutable_case_expr(); public: void unsafe_arena_set_allocated_case_expr( ::pg_query::CaseExpr* case_expr); ::pg_query::CaseExpr* unsafe_arena_release_case_expr(); // .pg_query.CaseWhen case_when = 28 [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* case_when); private: const ::pg_query::CaseWhen& _internal_case_when() const; ::pg_query::CaseWhen* _internal_mutable_case_when(); public: void unsafe_arena_set_allocated_case_when( ::pg_query::CaseWhen* case_when); ::pg_query::CaseWhen* unsafe_arena_release_case_when(); // .pg_query.CaseTestExpr case_test_expr = 29 [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* case_test_expr); private: const ::pg_query::CaseTestExpr& _internal_case_test_expr() const; ::pg_query::CaseTestExpr* _internal_mutable_case_test_expr(); public: void unsafe_arena_set_allocated_case_test_expr( ::pg_query::CaseTestExpr* case_test_expr); ::pg_query::CaseTestExpr* unsafe_arena_release_case_test_expr(); // .pg_query.ArrayExpr array_expr = 30 [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* array_expr); private: const ::pg_query::ArrayExpr& _internal_array_expr() const; ::pg_query::ArrayExpr* _internal_mutable_array_expr(); public: void unsafe_arena_set_allocated_array_expr( ::pg_query::ArrayExpr* array_expr); ::pg_query::ArrayExpr* unsafe_arena_release_array_expr(); // .pg_query.RowExpr row_expr = 31 [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* row_expr); private: const ::pg_query::RowExpr& _internal_row_expr() const; ::pg_query::RowExpr* _internal_mutable_row_expr(); public: void unsafe_arena_set_allocated_row_expr( ::pg_query::RowExpr* row_expr); ::pg_query::RowExpr* unsafe_arena_release_row_expr(); // .pg_query.RowCompareExpr row_compare_expr = 32 [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* row_compare_expr); private: const ::pg_query::RowCompareExpr& _internal_row_compare_expr() const; ::pg_query::RowCompareExpr* _internal_mutable_row_compare_expr(); public: void unsafe_arena_set_allocated_row_compare_expr( ::pg_query::RowCompareExpr* row_compare_expr); ::pg_query::RowCompareExpr* unsafe_arena_release_row_compare_expr(); // .pg_query.CoalesceExpr coalesce_expr = 33 [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* coalesce_expr); private: const ::pg_query::CoalesceExpr& _internal_coalesce_expr() const; ::pg_query::CoalesceExpr* _internal_mutable_coalesce_expr(); public: void unsafe_arena_set_allocated_coalesce_expr( ::pg_query::CoalesceExpr* coalesce_expr); ::pg_query::CoalesceExpr* unsafe_arena_release_coalesce_expr(); // .pg_query.MinMaxExpr min_max_expr = 34 [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* min_max_expr); private: const ::pg_query::MinMaxExpr& _internal_min_max_expr() const; ::pg_query::MinMaxExpr* _internal_mutable_min_max_expr(); public: void unsafe_arena_set_allocated_min_max_expr( ::pg_query::MinMaxExpr* min_max_expr); ::pg_query::MinMaxExpr* unsafe_arena_release_min_max_expr(); // .pg_query.SQLValueFunction sqlvalue_function = 35 [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* sqlvalue_function); private: const ::pg_query::SQLValueFunction& _internal_sqlvalue_function() const; ::pg_query::SQLValueFunction* _internal_mutable_sqlvalue_function(); public: void unsafe_arena_set_allocated_sqlvalue_function( ::pg_query::SQLValueFunction* sqlvalue_function); ::pg_query::SQLValueFunction* unsafe_arena_release_sqlvalue_function(); // .pg_query.XmlExpr xml_expr = 36 [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* xml_expr); private: const ::pg_query::XmlExpr& _internal_xml_expr() const; ::pg_query::XmlExpr* _internal_mutable_xml_expr(); public: void unsafe_arena_set_allocated_xml_expr( ::pg_query::XmlExpr* xml_expr); ::pg_query::XmlExpr* unsafe_arena_release_xml_expr(); // .pg_query.NullTest null_test = 37 [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* null_test); private: const ::pg_query::NullTest& _internal_null_test() const; ::pg_query::NullTest* _internal_mutable_null_test(); public: void unsafe_arena_set_allocated_null_test( ::pg_query::NullTest* null_test); ::pg_query::NullTest* unsafe_arena_release_null_test(); // .pg_query.BooleanTest boolean_test = 38 [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* boolean_test); private: const ::pg_query::BooleanTest& _internal_boolean_test() const; ::pg_query::BooleanTest* _internal_mutable_boolean_test(); public: void unsafe_arena_set_allocated_boolean_test( ::pg_query::BooleanTest* boolean_test); ::pg_query::BooleanTest* unsafe_arena_release_boolean_test(); // .pg_query.CoerceToDomain coerce_to_domain = 39 [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* coerce_to_domain); private: const ::pg_query::CoerceToDomain& _internal_coerce_to_domain() const; ::pg_query::CoerceToDomain* _internal_mutable_coerce_to_domain(); public: void unsafe_arena_set_allocated_coerce_to_domain( ::pg_query::CoerceToDomain* coerce_to_domain); ::pg_query::CoerceToDomain* unsafe_arena_release_coerce_to_domain(); // .pg_query.CoerceToDomainValue coerce_to_domain_value = 40 [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* coerce_to_domain_value); private: const ::pg_query::CoerceToDomainValue& _internal_coerce_to_domain_value() const; ::pg_query::CoerceToDomainValue* _internal_mutable_coerce_to_domain_value(); public: void unsafe_arena_set_allocated_coerce_to_domain_value( ::pg_query::CoerceToDomainValue* coerce_to_domain_value); ::pg_query::CoerceToDomainValue* unsafe_arena_release_coerce_to_domain_value(); // .pg_query.SetToDefault set_to_default = 41 [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* set_to_default); private: const ::pg_query::SetToDefault& _internal_set_to_default() const; ::pg_query::SetToDefault* _internal_mutable_set_to_default(); public: void unsafe_arena_set_allocated_set_to_default( ::pg_query::SetToDefault* set_to_default); ::pg_query::SetToDefault* unsafe_arena_release_set_to_default(); // .pg_query.CurrentOfExpr current_of_expr = 42 [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* current_of_expr); private: const ::pg_query::CurrentOfExpr& _internal_current_of_expr() const; ::pg_query::CurrentOfExpr* _internal_mutable_current_of_expr(); public: void unsafe_arena_set_allocated_current_of_expr( ::pg_query::CurrentOfExpr* current_of_expr); ::pg_query::CurrentOfExpr* unsafe_arena_release_current_of_expr(); // .pg_query.NextValueExpr next_value_expr = 43 [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* next_value_expr); private: const ::pg_query::NextValueExpr& _internal_next_value_expr() const; ::pg_query::NextValueExpr* _internal_mutable_next_value_expr(); public: void unsafe_arena_set_allocated_next_value_expr( ::pg_query::NextValueExpr* next_value_expr); ::pg_query::NextValueExpr* unsafe_arena_release_next_value_expr(); // .pg_query.InferenceElem inference_elem = 44 [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* inference_elem); private: const ::pg_query::InferenceElem& _internal_inference_elem() const; ::pg_query::InferenceElem* _internal_mutable_inference_elem(); public: void unsafe_arena_set_allocated_inference_elem( ::pg_query::InferenceElem* inference_elem); ::pg_query::InferenceElem* unsafe_arena_release_inference_elem(); // .pg_query.TargetEntry target_entry = 45 [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* target_entry); private: const ::pg_query::TargetEntry& _internal_target_entry() const; ::pg_query::TargetEntry* _internal_mutable_target_entry(); public: void unsafe_arena_set_allocated_target_entry( ::pg_query::TargetEntry* target_entry); ::pg_query::TargetEntry* unsafe_arena_release_target_entry(); // .pg_query.RangeTblRef range_tbl_ref = 46 [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* range_tbl_ref); private: const ::pg_query::RangeTblRef& _internal_range_tbl_ref() const; ::pg_query::RangeTblRef* _internal_mutable_range_tbl_ref(); public: void unsafe_arena_set_allocated_range_tbl_ref( ::pg_query::RangeTblRef* range_tbl_ref); ::pg_query::RangeTblRef* unsafe_arena_release_range_tbl_ref(); // .pg_query.JoinExpr join_expr = 47 [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* join_expr); private: const ::pg_query::JoinExpr& _internal_join_expr() const; ::pg_query::JoinExpr* _internal_mutable_join_expr(); public: void unsafe_arena_set_allocated_join_expr( ::pg_query::JoinExpr* join_expr); ::pg_query::JoinExpr* unsafe_arena_release_join_expr(); // .pg_query.FromExpr from_expr = 48 [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* from_expr); private: const ::pg_query::FromExpr& _internal_from_expr() const; ::pg_query::FromExpr* _internal_mutable_from_expr(); public: void unsafe_arena_set_allocated_from_expr( ::pg_query::FromExpr* from_expr); ::pg_query::FromExpr* unsafe_arena_release_from_expr(); // .pg_query.OnConflictExpr on_conflict_expr = 49 [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* on_conflict_expr); private: const ::pg_query::OnConflictExpr& _internal_on_conflict_expr() const; ::pg_query::OnConflictExpr* _internal_mutable_on_conflict_expr(); public: void unsafe_arena_set_allocated_on_conflict_expr( ::pg_query::OnConflictExpr* on_conflict_expr); ::pg_query::OnConflictExpr* unsafe_arena_release_on_conflict_expr(); // .pg_query.IntoClause into_clause = 50 [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* into_clause); private: const ::pg_query::IntoClause& _internal_into_clause() const; ::pg_query::IntoClause* _internal_mutable_into_clause(); public: void unsafe_arena_set_allocated_into_clause( ::pg_query::IntoClause* into_clause); ::pg_query::IntoClause* unsafe_arena_release_into_clause(); // .pg_query.MergeAction merge_action = 51 [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* merge_action); private: const ::pg_query::MergeAction& _internal_merge_action() const; ::pg_query::MergeAction* _internal_mutable_merge_action(); public: void unsafe_arena_set_allocated_merge_action( ::pg_query::MergeAction* merge_action); ::pg_query::MergeAction* unsafe_arena_release_merge_action(); // .pg_query.RawStmt raw_stmt = 52 [json_name = "RawStmt"]; bool has_raw_stmt() const; private: bool _internal_has_raw_stmt() const; public: void clear_raw_stmt(); const ::pg_query::RawStmt& raw_stmt() const; PROTOBUF_NODISCARD ::pg_query::RawStmt* release_raw_stmt(); ::pg_query::RawStmt* mutable_raw_stmt(); void set_allocated_raw_stmt(::pg_query::RawStmt* raw_stmt); private: const ::pg_query::RawStmt& _internal_raw_stmt() const; ::pg_query::RawStmt* _internal_mutable_raw_stmt(); public: void unsafe_arena_set_allocated_raw_stmt( ::pg_query::RawStmt* raw_stmt); ::pg_query::RawStmt* unsafe_arena_release_raw_stmt(); // .pg_query.Query query = 53 [json_name = "Query"]; bool has_query() const; private: bool _internal_has_query() const; public: void clear_query(); const ::pg_query::Query& query() const; PROTOBUF_NODISCARD ::pg_query::Query* release_query(); ::pg_query::Query* mutable_query(); void set_allocated_query(::pg_query::Query* query); private: const ::pg_query::Query& _internal_query() const; ::pg_query::Query* _internal_mutable_query(); public: void unsafe_arena_set_allocated_query( ::pg_query::Query* query); ::pg_query::Query* unsafe_arena_release_query(); // .pg_query.InsertStmt insert_stmt = 54 [json_name = "InsertStmt"]; bool has_insert_stmt() const; private: bool _internal_has_insert_stmt() const; public: void clear_insert_stmt(); const ::pg_query::InsertStmt& insert_stmt() const; PROTOBUF_NODISCARD ::pg_query::InsertStmt* release_insert_stmt(); ::pg_query::InsertStmt* mutable_insert_stmt(); void set_allocated_insert_stmt(::pg_query::InsertStmt* insert_stmt); private: const ::pg_query::InsertStmt& _internal_insert_stmt() const; ::pg_query::InsertStmt* _internal_mutable_insert_stmt(); public: void unsafe_arena_set_allocated_insert_stmt( ::pg_query::InsertStmt* insert_stmt); ::pg_query::InsertStmt* unsafe_arena_release_insert_stmt(); // .pg_query.DeleteStmt delete_stmt = 55 [json_name = "DeleteStmt"]; bool has_delete_stmt() const; private: bool _internal_has_delete_stmt() const; public: void clear_delete_stmt(); const ::pg_query::DeleteStmt& delete_stmt() const; PROTOBUF_NODISCARD ::pg_query::DeleteStmt* release_delete_stmt(); ::pg_query::DeleteStmt* mutable_delete_stmt(); void set_allocated_delete_stmt(::pg_query::DeleteStmt* delete_stmt); private: const ::pg_query::DeleteStmt& _internal_delete_stmt() const; ::pg_query::DeleteStmt* _internal_mutable_delete_stmt(); public: void unsafe_arena_set_allocated_delete_stmt( ::pg_query::DeleteStmt* delete_stmt); ::pg_query::DeleteStmt* unsafe_arena_release_delete_stmt(); // .pg_query.UpdateStmt update_stmt = 56 [json_name = "UpdateStmt"]; bool has_update_stmt() const; private: bool _internal_has_update_stmt() const; public: void clear_update_stmt(); const ::pg_query::UpdateStmt& update_stmt() const; PROTOBUF_NODISCARD ::pg_query::UpdateStmt* release_update_stmt(); ::pg_query::UpdateStmt* mutable_update_stmt(); void set_allocated_update_stmt(::pg_query::UpdateStmt* update_stmt); private: const ::pg_query::UpdateStmt& _internal_update_stmt() const; ::pg_query::UpdateStmt* _internal_mutable_update_stmt(); public: void unsafe_arena_set_allocated_update_stmt( ::pg_query::UpdateStmt* update_stmt); ::pg_query::UpdateStmt* unsafe_arena_release_update_stmt(); // .pg_query.MergeStmt merge_stmt = 57 [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* merge_stmt); private: const ::pg_query::MergeStmt& _internal_merge_stmt() const; ::pg_query::MergeStmt* _internal_mutable_merge_stmt(); public: void unsafe_arena_set_allocated_merge_stmt( ::pg_query::MergeStmt* merge_stmt); ::pg_query::MergeStmt* unsafe_arena_release_merge_stmt(); // .pg_query.SelectStmt select_stmt = 58 [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* select_stmt); private: const ::pg_query::SelectStmt& _internal_select_stmt() const; ::pg_query::SelectStmt* _internal_mutable_select_stmt(); public: void unsafe_arena_set_allocated_select_stmt( ::pg_query::SelectStmt* select_stmt); ::pg_query::SelectStmt* unsafe_arena_release_select_stmt(); // .pg_query.ReturnStmt return_stmt = 59 [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* return_stmt); private: const ::pg_query::ReturnStmt& _internal_return_stmt() const; ::pg_query::ReturnStmt* _internal_mutable_return_stmt(); public: void unsafe_arena_set_allocated_return_stmt( ::pg_query::ReturnStmt* return_stmt); ::pg_query::ReturnStmt* unsafe_arena_release_return_stmt(); // .pg_query.PLAssignStmt plassign_stmt = 60 [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* plassign_stmt); private: const ::pg_query::PLAssignStmt& _internal_plassign_stmt() const; ::pg_query::PLAssignStmt* _internal_mutable_plassign_stmt(); public: void unsafe_arena_set_allocated_plassign_stmt( ::pg_query::PLAssignStmt* plassign_stmt); ::pg_query::PLAssignStmt* unsafe_arena_release_plassign_stmt(); // .pg_query.AlterTableStmt alter_table_stmt = 61 [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* alter_table_stmt); private: const ::pg_query::AlterTableStmt& _internal_alter_table_stmt() const; ::pg_query::AlterTableStmt* _internal_mutable_alter_table_stmt(); public: void unsafe_arena_set_allocated_alter_table_stmt( ::pg_query::AlterTableStmt* alter_table_stmt); ::pg_query::AlterTableStmt* unsafe_arena_release_alter_table_stmt(); // .pg_query.AlterTableCmd alter_table_cmd = 62 [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* alter_table_cmd); private: const ::pg_query::AlterTableCmd& _internal_alter_table_cmd() const; ::pg_query::AlterTableCmd* _internal_mutable_alter_table_cmd(); public: void unsafe_arena_set_allocated_alter_table_cmd( ::pg_query::AlterTableCmd* alter_table_cmd); ::pg_query::AlterTableCmd* unsafe_arena_release_alter_table_cmd(); // .pg_query.AlterDomainStmt alter_domain_stmt = 63 [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* alter_domain_stmt); private: const ::pg_query::AlterDomainStmt& _internal_alter_domain_stmt() const; ::pg_query::AlterDomainStmt* _internal_mutable_alter_domain_stmt(); public: void unsafe_arena_set_allocated_alter_domain_stmt( ::pg_query::AlterDomainStmt* alter_domain_stmt); ::pg_query::AlterDomainStmt* unsafe_arena_release_alter_domain_stmt(); // .pg_query.SetOperationStmt set_operation_stmt = 64 [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* set_operation_stmt); private: const ::pg_query::SetOperationStmt& _internal_set_operation_stmt() const; ::pg_query::SetOperationStmt* _internal_mutable_set_operation_stmt(); public: void unsafe_arena_set_allocated_set_operation_stmt( ::pg_query::SetOperationStmt* set_operation_stmt); ::pg_query::SetOperationStmt* unsafe_arena_release_set_operation_stmt(); // .pg_query.GrantStmt grant_stmt = 65 [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* grant_stmt); private: const ::pg_query::GrantStmt& _internal_grant_stmt() const; ::pg_query::GrantStmt* _internal_mutable_grant_stmt(); public: void unsafe_arena_set_allocated_grant_stmt( ::pg_query::GrantStmt* grant_stmt); ::pg_query::GrantStmt* unsafe_arena_release_grant_stmt(); // .pg_query.GrantRoleStmt grant_role_stmt = 66 [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* grant_role_stmt); private: const ::pg_query::GrantRoleStmt& _internal_grant_role_stmt() const; ::pg_query::GrantRoleStmt* _internal_mutable_grant_role_stmt(); public: void unsafe_arena_set_allocated_grant_role_stmt( ::pg_query::GrantRoleStmt* grant_role_stmt); ::pg_query::GrantRoleStmt* unsafe_arena_release_grant_role_stmt(); // .pg_query.AlterDefaultPrivilegesStmt alter_default_privileges_stmt = 67 [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* alter_default_privileges_stmt); private: const ::pg_query::AlterDefaultPrivilegesStmt& _internal_alter_default_privileges_stmt() const; ::pg_query::AlterDefaultPrivilegesStmt* _internal_mutable_alter_default_privileges_stmt(); public: void unsafe_arena_set_allocated_alter_default_privileges_stmt( ::pg_query::AlterDefaultPrivilegesStmt* alter_default_privileges_stmt); ::pg_query::AlterDefaultPrivilegesStmt* unsafe_arena_release_alter_default_privileges_stmt(); // .pg_query.ClosePortalStmt close_portal_stmt = 68 [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* close_portal_stmt); private: const ::pg_query::ClosePortalStmt& _internal_close_portal_stmt() const; ::pg_query::ClosePortalStmt* _internal_mutable_close_portal_stmt(); public: void unsafe_arena_set_allocated_close_portal_stmt( ::pg_query::ClosePortalStmt* close_portal_stmt); ::pg_query::ClosePortalStmt* unsafe_arena_release_close_portal_stmt(); // .pg_query.ClusterStmt cluster_stmt = 69 [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* cluster_stmt); private: const ::pg_query::ClusterStmt& _internal_cluster_stmt() const; ::pg_query::ClusterStmt* _internal_mutable_cluster_stmt(); public: void unsafe_arena_set_allocated_cluster_stmt( ::pg_query::ClusterStmt* cluster_stmt); ::pg_query::ClusterStmt* unsafe_arena_release_cluster_stmt(); // .pg_query.CopyStmt copy_stmt = 70 [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* copy_stmt); private: const ::pg_query::CopyStmt& _internal_copy_stmt() const; ::pg_query::CopyStmt* _internal_mutable_copy_stmt(); public: void unsafe_arena_set_allocated_copy_stmt( ::pg_query::CopyStmt* copy_stmt); ::pg_query::CopyStmt* unsafe_arena_release_copy_stmt(); // .pg_query.CreateStmt create_stmt = 71 [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* create_stmt); private: const ::pg_query::CreateStmt& _internal_create_stmt() const; ::pg_query::CreateStmt* _internal_mutable_create_stmt(); public: void unsafe_arena_set_allocated_create_stmt( ::pg_query::CreateStmt* create_stmt); ::pg_query::CreateStmt* unsafe_arena_release_create_stmt(); // .pg_query.DefineStmt define_stmt = 72 [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* define_stmt); private: const ::pg_query::DefineStmt& _internal_define_stmt() const; ::pg_query::DefineStmt* _internal_mutable_define_stmt(); public: void unsafe_arena_set_allocated_define_stmt( ::pg_query::DefineStmt* define_stmt); ::pg_query::DefineStmt* unsafe_arena_release_define_stmt(); // .pg_query.DropStmt drop_stmt = 73 [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* drop_stmt); private: const ::pg_query::DropStmt& _internal_drop_stmt() const; ::pg_query::DropStmt* _internal_mutable_drop_stmt(); public: void unsafe_arena_set_allocated_drop_stmt( ::pg_query::DropStmt* drop_stmt); ::pg_query::DropStmt* unsafe_arena_release_drop_stmt(); // .pg_query.TruncateStmt truncate_stmt = 74 [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* truncate_stmt); private: const ::pg_query::TruncateStmt& _internal_truncate_stmt() const; ::pg_query::TruncateStmt* _internal_mutable_truncate_stmt(); public: void unsafe_arena_set_allocated_truncate_stmt( ::pg_query::TruncateStmt* truncate_stmt); ::pg_query::TruncateStmt* unsafe_arena_release_truncate_stmt(); // .pg_query.CommentStmt comment_stmt = 75 [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* comment_stmt); private: const ::pg_query::CommentStmt& _internal_comment_stmt() const; ::pg_query::CommentStmt* _internal_mutable_comment_stmt(); public: void unsafe_arena_set_allocated_comment_stmt( ::pg_query::CommentStmt* comment_stmt); ::pg_query::CommentStmt* unsafe_arena_release_comment_stmt(); // .pg_query.FetchStmt fetch_stmt = 76 [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* fetch_stmt); private: const ::pg_query::FetchStmt& _internal_fetch_stmt() const; ::pg_query::FetchStmt* _internal_mutable_fetch_stmt(); public: void unsafe_arena_set_allocated_fetch_stmt( ::pg_query::FetchStmt* fetch_stmt); ::pg_query::FetchStmt* unsafe_arena_release_fetch_stmt(); // .pg_query.IndexStmt index_stmt = 77 [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* index_stmt); private: const ::pg_query::IndexStmt& _internal_index_stmt() const; ::pg_query::IndexStmt* _internal_mutable_index_stmt(); public: void unsafe_arena_set_allocated_index_stmt( ::pg_query::IndexStmt* index_stmt); ::pg_query::IndexStmt* unsafe_arena_release_index_stmt(); // .pg_query.CreateFunctionStmt create_function_stmt = 78 [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* create_function_stmt); private: const ::pg_query::CreateFunctionStmt& _internal_create_function_stmt() const; ::pg_query::CreateFunctionStmt* _internal_mutable_create_function_stmt(); public: void unsafe_arena_set_allocated_create_function_stmt( ::pg_query::CreateFunctionStmt* create_function_stmt); ::pg_query::CreateFunctionStmt* unsafe_arena_release_create_function_stmt(); // .pg_query.AlterFunctionStmt alter_function_stmt = 79 [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* alter_function_stmt); private: const ::pg_query::AlterFunctionStmt& _internal_alter_function_stmt() const; ::pg_query::AlterFunctionStmt* _internal_mutable_alter_function_stmt(); public: void unsafe_arena_set_allocated_alter_function_stmt( ::pg_query::AlterFunctionStmt* alter_function_stmt); ::pg_query::AlterFunctionStmt* unsafe_arena_release_alter_function_stmt(); // .pg_query.DoStmt do_stmt = 80 [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* do_stmt); private: const ::pg_query::DoStmt& _internal_do_stmt() const; ::pg_query::DoStmt* _internal_mutable_do_stmt(); public: void unsafe_arena_set_allocated_do_stmt( ::pg_query::DoStmt* do_stmt); ::pg_query::DoStmt* unsafe_arena_release_do_stmt(); // .pg_query.RenameStmt rename_stmt = 81 [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* rename_stmt); private: const ::pg_query::RenameStmt& _internal_rename_stmt() const; ::pg_query::RenameStmt* _internal_mutable_rename_stmt(); public: void unsafe_arena_set_allocated_rename_stmt( ::pg_query::RenameStmt* rename_stmt); ::pg_query::RenameStmt* unsafe_arena_release_rename_stmt(); // .pg_query.RuleStmt rule_stmt = 82 [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* rule_stmt); private: const ::pg_query::RuleStmt& _internal_rule_stmt() const; ::pg_query::RuleStmt* _internal_mutable_rule_stmt(); public: void unsafe_arena_set_allocated_rule_stmt( ::pg_query::RuleStmt* rule_stmt); ::pg_query::RuleStmt* unsafe_arena_release_rule_stmt(); // .pg_query.NotifyStmt notify_stmt = 83 [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* notify_stmt); private: const ::pg_query::NotifyStmt& _internal_notify_stmt() const; ::pg_query::NotifyStmt* _internal_mutable_notify_stmt(); public: void unsafe_arena_set_allocated_notify_stmt( ::pg_query::NotifyStmt* notify_stmt); ::pg_query::NotifyStmt* unsafe_arena_release_notify_stmt(); // .pg_query.ListenStmt listen_stmt = 84 [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* listen_stmt); private: const ::pg_query::ListenStmt& _internal_listen_stmt() const; ::pg_query::ListenStmt* _internal_mutable_listen_stmt(); public: void unsafe_arena_set_allocated_listen_stmt( ::pg_query::ListenStmt* listen_stmt); ::pg_query::ListenStmt* unsafe_arena_release_listen_stmt(); // .pg_query.UnlistenStmt unlisten_stmt = 85 [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* unlisten_stmt); private: const ::pg_query::UnlistenStmt& _internal_unlisten_stmt() const; ::pg_query::UnlistenStmt* _internal_mutable_unlisten_stmt(); public: void unsafe_arena_set_allocated_unlisten_stmt( ::pg_query::UnlistenStmt* unlisten_stmt); ::pg_query::UnlistenStmt* unsafe_arena_release_unlisten_stmt(); // .pg_query.TransactionStmt transaction_stmt = 86 [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* transaction_stmt); private: const ::pg_query::TransactionStmt& _internal_transaction_stmt() const; ::pg_query::TransactionStmt* _internal_mutable_transaction_stmt(); public: void unsafe_arena_set_allocated_transaction_stmt( ::pg_query::TransactionStmt* transaction_stmt); ::pg_query::TransactionStmt* unsafe_arena_release_transaction_stmt(); // .pg_query.ViewStmt view_stmt = 87 [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* view_stmt); private: const ::pg_query::ViewStmt& _internal_view_stmt() const; ::pg_query::ViewStmt* _internal_mutable_view_stmt(); public: void unsafe_arena_set_allocated_view_stmt( ::pg_query::ViewStmt* view_stmt); ::pg_query::ViewStmt* unsafe_arena_release_view_stmt(); // .pg_query.LoadStmt load_stmt = 88 [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* load_stmt); private: const ::pg_query::LoadStmt& _internal_load_stmt() const; ::pg_query::LoadStmt* _internal_mutable_load_stmt(); public: void unsafe_arena_set_allocated_load_stmt( ::pg_query::LoadStmt* load_stmt); ::pg_query::LoadStmt* unsafe_arena_release_load_stmt(); // .pg_query.CreateDomainStmt create_domain_stmt = 89 [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* create_domain_stmt); private: const ::pg_query::CreateDomainStmt& _internal_create_domain_stmt() const; ::pg_query::CreateDomainStmt* _internal_mutable_create_domain_stmt(); public: void unsafe_arena_set_allocated_create_domain_stmt( ::pg_query::CreateDomainStmt* create_domain_stmt); ::pg_query::CreateDomainStmt* unsafe_arena_release_create_domain_stmt(); // .pg_query.CreatedbStmt createdb_stmt = 90 [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* createdb_stmt); private: const ::pg_query::CreatedbStmt& _internal_createdb_stmt() const; ::pg_query::CreatedbStmt* _internal_mutable_createdb_stmt(); public: void unsafe_arena_set_allocated_createdb_stmt( ::pg_query::CreatedbStmt* createdb_stmt); ::pg_query::CreatedbStmt* unsafe_arena_release_createdb_stmt(); // .pg_query.DropdbStmt dropdb_stmt = 91 [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* dropdb_stmt); private: const ::pg_query::DropdbStmt& _internal_dropdb_stmt() const; ::pg_query::DropdbStmt* _internal_mutable_dropdb_stmt(); public: void unsafe_arena_set_allocated_dropdb_stmt( ::pg_query::DropdbStmt* dropdb_stmt); ::pg_query::DropdbStmt* unsafe_arena_release_dropdb_stmt(); // .pg_query.VacuumStmt vacuum_stmt = 92 [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* vacuum_stmt); private: const ::pg_query::VacuumStmt& _internal_vacuum_stmt() const; ::pg_query::VacuumStmt* _internal_mutable_vacuum_stmt(); public: void unsafe_arena_set_allocated_vacuum_stmt( ::pg_query::VacuumStmt* vacuum_stmt); ::pg_query::VacuumStmt* unsafe_arena_release_vacuum_stmt(); // .pg_query.ExplainStmt explain_stmt = 93 [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* explain_stmt); private: const ::pg_query::ExplainStmt& _internal_explain_stmt() const; ::pg_query::ExplainStmt* _internal_mutable_explain_stmt(); public: void unsafe_arena_set_allocated_explain_stmt( ::pg_query::ExplainStmt* explain_stmt); ::pg_query::ExplainStmt* unsafe_arena_release_explain_stmt(); // .pg_query.CreateTableAsStmt create_table_as_stmt = 94 [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* create_table_as_stmt); private: const ::pg_query::CreateTableAsStmt& _internal_create_table_as_stmt() const; ::pg_query::CreateTableAsStmt* _internal_mutable_create_table_as_stmt(); public: void unsafe_arena_set_allocated_create_table_as_stmt( ::pg_query::CreateTableAsStmt* create_table_as_stmt); ::pg_query::CreateTableAsStmt* unsafe_arena_release_create_table_as_stmt(); // .pg_query.CreateSeqStmt create_seq_stmt = 95 [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* create_seq_stmt); private: const ::pg_query::CreateSeqStmt& _internal_create_seq_stmt() const; ::pg_query::CreateSeqStmt* _internal_mutable_create_seq_stmt(); public: void unsafe_arena_set_allocated_create_seq_stmt( ::pg_query::CreateSeqStmt* create_seq_stmt); ::pg_query::CreateSeqStmt* unsafe_arena_release_create_seq_stmt(); // .pg_query.AlterSeqStmt alter_seq_stmt = 96 [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* alter_seq_stmt); private: const ::pg_query::AlterSeqStmt& _internal_alter_seq_stmt() const; ::pg_query::AlterSeqStmt* _internal_mutable_alter_seq_stmt(); public: void unsafe_arena_set_allocated_alter_seq_stmt( ::pg_query::AlterSeqStmt* alter_seq_stmt); ::pg_query::AlterSeqStmt* unsafe_arena_release_alter_seq_stmt(); // .pg_query.VariableSetStmt variable_set_stmt = 97 [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* variable_set_stmt); private: const ::pg_query::VariableSetStmt& _internal_variable_set_stmt() const; ::pg_query::VariableSetStmt* _internal_mutable_variable_set_stmt(); public: void unsafe_arena_set_allocated_variable_set_stmt( ::pg_query::VariableSetStmt* variable_set_stmt); ::pg_query::VariableSetStmt* unsafe_arena_release_variable_set_stmt(); // .pg_query.VariableShowStmt variable_show_stmt = 98 [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* variable_show_stmt); private: const ::pg_query::VariableShowStmt& _internal_variable_show_stmt() const; ::pg_query::VariableShowStmt* _internal_mutable_variable_show_stmt(); public: void unsafe_arena_set_allocated_variable_show_stmt( ::pg_query::VariableShowStmt* variable_show_stmt); ::pg_query::VariableShowStmt* unsafe_arena_release_variable_show_stmt(); // .pg_query.DiscardStmt discard_stmt = 99 [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* discard_stmt); private: const ::pg_query::DiscardStmt& _internal_discard_stmt() const; ::pg_query::DiscardStmt* _internal_mutable_discard_stmt(); public: void unsafe_arena_set_allocated_discard_stmt( ::pg_query::DiscardStmt* discard_stmt); ::pg_query::DiscardStmt* unsafe_arena_release_discard_stmt(); // .pg_query.CreateTrigStmt create_trig_stmt = 100 [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* create_trig_stmt); private: const ::pg_query::CreateTrigStmt& _internal_create_trig_stmt() const; ::pg_query::CreateTrigStmt* _internal_mutable_create_trig_stmt(); public: void unsafe_arena_set_allocated_create_trig_stmt( ::pg_query::CreateTrigStmt* create_trig_stmt); ::pg_query::CreateTrigStmt* unsafe_arena_release_create_trig_stmt(); // .pg_query.CreatePLangStmt create_plang_stmt = 101 [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* create_plang_stmt); private: const ::pg_query::CreatePLangStmt& _internal_create_plang_stmt() const; ::pg_query::CreatePLangStmt* _internal_mutable_create_plang_stmt(); public: void unsafe_arena_set_allocated_create_plang_stmt( ::pg_query::CreatePLangStmt* create_plang_stmt); ::pg_query::CreatePLangStmt* unsafe_arena_release_create_plang_stmt(); // .pg_query.CreateRoleStmt create_role_stmt = 102 [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* create_role_stmt); private: const ::pg_query::CreateRoleStmt& _internal_create_role_stmt() const; ::pg_query::CreateRoleStmt* _internal_mutable_create_role_stmt(); public: void unsafe_arena_set_allocated_create_role_stmt( ::pg_query::CreateRoleStmt* create_role_stmt); ::pg_query::CreateRoleStmt* unsafe_arena_release_create_role_stmt(); // .pg_query.AlterRoleStmt alter_role_stmt = 103 [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* alter_role_stmt); private: const ::pg_query::AlterRoleStmt& _internal_alter_role_stmt() const; ::pg_query::AlterRoleStmt* _internal_mutable_alter_role_stmt(); public: void unsafe_arena_set_allocated_alter_role_stmt( ::pg_query::AlterRoleStmt* alter_role_stmt); ::pg_query::AlterRoleStmt* unsafe_arena_release_alter_role_stmt(); // .pg_query.DropRoleStmt drop_role_stmt = 104 [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* drop_role_stmt); private: const ::pg_query::DropRoleStmt& _internal_drop_role_stmt() const; ::pg_query::DropRoleStmt* _internal_mutable_drop_role_stmt(); public: void unsafe_arena_set_allocated_drop_role_stmt( ::pg_query::DropRoleStmt* drop_role_stmt); ::pg_query::DropRoleStmt* unsafe_arena_release_drop_role_stmt(); // .pg_query.LockStmt lock_stmt = 105 [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* lock_stmt); private: const ::pg_query::LockStmt& _internal_lock_stmt() const; ::pg_query::LockStmt* _internal_mutable_lock_stmt(); public: void unsafe_arena_set_allocated_lock_stmt( ::pg_query::LockStmt* lock_stmt); ::pg_query::LockStmt* unsafe_arena_release_lock_stmt(); // .pg_query.ConstraintsSetStmt constraints_set_stmt = 106 [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* constraints_set_stmt); private: const ::pg_query::ConstraintsSetStmt& _internal_constraints_set_stmt() const; ::pg_query::ConstraintsSetStmt* _internal_mutable_constraints_set_stmt(); public: void unsafe_arena_set_allocated_constraints_set_stmt( ::pg_query::ConstraintsSetStmt* constraints_set_stmt); ::pg_query::ConstraintsSetStmt* unsafe_arena_release_constraints_set_stmt(); // .pg_query.ReindexStmt reindex_stmt = 107 [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* reindex_stmt); private: const ::pg_query::ReindexStmt& _internal_reindex_stmt() const; ::pg_query::ReindexStmt* _internal_mutable_reindex_stmt(); public: void unsafe_arena_set_allocated_reindex_stmt( ::pg_query::ReindexStmt* reindex_stmt); ::pg_query::ReindexStmt* unsafe_arena_release_reindex_stmt(); // .pg_query.CheckPointStmt check_point_stmt = 108 [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* check_point_stmt); private: const ::pg_query::CheckPointStmt& _internal_check_point_stmt() const; ::pg_query::CheckPointStmt* _internal_mutable_check_point_stmt(); public: void unsafe_arena_set_allocated_check_point_stmt( ::pg_query::CheckPointStmt* check_point_stmt); ::pg_query::CheckPointStmt* unsafe_arena_release_check_point_stmt(); // .pg_query.CreateSchemaStmt create_schema_stmt = 109 [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* create_schema_stmt); private: const ::pg_query::CreateSchemaStmt& _internal_create_schema_stmt() const; ::pg_query::CreateSchemaStmt* _internal_mutable_create_schema_stmt(); public: void unsafe_arena_set_allocated_create_schema_stmt( ::pg_query::CreateSchemaStmt* create_schema_stmt); ::pg_query::CreateSchemaStmt* unsafe_arena_release_create_schema_stmt(); // .pg_query.AlterDatabaseStmt alter_database_stmt = 110 [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* alter_database_stmt); private: const ::pg_query::AlterDatabaseStmt& _internal_alter_database_stmt() const; ::pg_query::AlterDatabaseStmt* _internal_mutable_alter_database_stmt(); public: void unsafe_arena_set_allocated_alter_database_stmt( ::pg_query::AlterDatabaseStmt* alter_database_stmt); ::pg_query::AlterDatabaseStmt* unsafe_arena_release_alter_database_stmt(); // .pg_query.AlterDatabaseRefreshCollStmt alter_database_refresh_coll_stmt = 111 [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* 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: void unsafe_arena_set_allocated_alter_database_refresh_coll_stmt( ::pg_query::AlterDatabaseRefreshCollStmt* alter_database_refresh_coll_stmt); ::pg_query::AlterDatabaseRefreshCollStmt* unsafe_arena_release_alter_database_refresh_coll_stmt(); // .pg_query.AlterDatabaseSetStmt alter_database_set_stmt = 112 [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* alter_database_set_stmt); private: const ::pg_query::AlterDatabaseSetStmt& _internal_alter_database_set_stmt() const; ::pg_query::AlterDatabaseSetStmt* _internal_mutable_alter_database_set_stmt(); public: void unsafe_arena_set_allocated_alter_database_set_stmt( ::pg_query::AlterDatabaseSetStmt* alter_database_set_stmt); ::pg_query::AlterDatabaseSetStmt* unsafe_arena_release_alter_database_set_stmt(); // .pg_query.AlterRoleSetStmt alter_role_set_stmt = 113 [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* alter_role_set_stmt); private: const ::pg_query::AlterRoleSetStmt& _internal_alter_role_set_stmt() const; ::pg_query::AlterRoleSetStmt* _internal_mutable_alter_role_set_stmt(); public: void unsafe_arena_set_allocated_alter_role_set_stmt( ::pg_query::AlterRoleSetStmt* alter_role_set_stmt); ::pg_query::AlterRoleSetStmt* unsafe_arena_release_alter_role_set_stmt(); // .pg_query.CreateConversionStmt create_conversion_stmt = 114 [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* create_conversion_stmt); private: const ::pg_query::CreateConversionStmt& _internal_create_conversion_stmt() const; ::pg_query::CreateConversionStmt* _internal_mutable_create_conversion_stmt(); public: void unsafe_arena_set_allocated_create_conversion_stmt( ::pg_query::CreateConversionStmt* create_conversion_stmt); ::pg_query::CreateConversionStmt* unsafe_arena_release_create_conversion_stmt(); // .pg_query.CreateCastStmt create_cast_stmt = 115 [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* create_cast_stmt); private: const ::pg_query::CreateCastStmt& _internal_create_cast_stmt() const; ::pg_query::CreateCastStmt* _internal_mutable_create_cast_stmt(); public: void unsafe_arena_set_allocated_create_cast_stmt( ::pg_query::CreateCastStmt* create_cast_stmt); ::pg_query::CreateCastStmt* unsafe_arena_release_create_cast_stmt(); // .pg_query.CreateOpClassStmt create_op_class_stmt = 116 [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* create_op_class_stmt); private: const ::pg_query::CreateOpClassStmt& _internal_create_op_class_stmt() const; ::pg_query::CreateOpClassStmt* _internal_mutable_create_op_class_stmt(); public: void unsafe_arena_set_allocated_create_op_class_stmt( ::pg_query::CreateOpClassStmt* create_op_class_stmt); ::pg_query::CreateOpClassStmt* unsafe_arena_release_create_op_class_stmt(); // .pg_query.CreateOpFamilyStmt create_op_family_stmt = 117 [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* create_op_family_stmt); private: const ::pg_query::CreateOpFamilyStmt& _internal_create_op_family_stmt() const; ::pg_query::CreateOpFamilyStmt* _internal_mutable_create_op_family_stmt(); public: void unsafe_arena_set_allocated_create_op_family_stmt( ::pg_query::CreateOpFamilyStmt* create_op_family_stmt); ::pg_query::CreateOpFamilyStmt* unsafe_arena_release_create_op_family_stmt(); // .pg_query.AlterOpFamilyStmt alter_op_family_stmt = 118 [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* alter_op_family_stmt); private: const ::pg_query::AlterOpFamilyStmt& _internal_alter_op_family_stmt() const; ::pg_query::AlterOpFamilyStmt* _internal_mutable_alter_op_family_stmt(); public: void unsafe_arena_set_allocated_alter_op_family_stmt( ::pg_query::AlterOpFamilyStmt* alter_op_family_stmt); ::pg_query::AlterOpFamilyStmt* unsafe_arena_release_alter_op_family_stmt(); // .pg_query.PrepareStmt prepare_stmt = 119 [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* prepare_stmt); private: const ::pg_query::PrepareStmt& _internal_prepare_stmt() const; ::pg_query::PrepareStmt* _internal_mutable_prepare_stmt(); public: void unsafe_arena_set_allocated_prepare_stmt( ::pg_query::PrepareStmt* prepare_stmt); ::pg_query::PrepareStmt* unsafe_arena_release_prepare_stmt(); // .pg_query.ExecuteStmt execute_stmt = 120 [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* execute_stmt); private: const ::pg_query::ExecuteStmt& _internal_execute_stmt() const; ::pg_query::ExecuteStmt* _internal_mutable_execute_stmt(); public: void unsafe_arena_set_allocated_execute_stmt( ::pg_query::ExecuteStmt* execute_stmt); ::pg_query::ExecuteStmt* unsafe_arena_release_execute_stmt(); // .pg_query.DeallocateStmt deallocate_stmt = 121 [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* deallocate_stmt); private: const ::pg_query::DeallocateStmt& _internal_deallocate_stmt() const; ::pg_query::DeallocateStmt* _internal_mutable_deallocate_stmt(); public: void unsafe_arena_set_allocated_deallocate_stmt( ::pg_query::DeallocateStmt* deallocate_stmt); ::pg_query::DeallocateStmt* unsafe_arena_release_deallocate_stmt(); // .pg_query.DeclareCursorStmt declare_cursor_stmt = 122 [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* declare_cursor_stmt); private: const ::pg_query::DeclareCursorStmt& _internal_declare_cursor_stmt() const; ::pg_query::DeclareCursorStmt* _internal_mutable_declare_cursor_stmt(); public: void unsafe_arena_set_allocated_declare_cursor_stmt( ::pg_query::DeclareCursorStmt* declare_cursor_stmt); ::pg_query::DeclareCursorStmt* unsafe_arena_release_declare_cursor_stmt(); // .pg_query.CreateTableSpaceStmt create_table_space_stmt = 123 [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* create_table_space_stmt); private: const ::pg_query::CreateTableSpaceStmt& _internal_create_table_space_stmt() const; ::pg_query::CreateTableSpaceStmt* _internal_mutable_create_table_space_stmt(); public: void unsafe_arena_set_allocated_create_table_space_stmt( ::pg_query::CreateTableSpaceStmt* create_table_space_stmt); ::pg_query::CreateTableSpaceStmt* unsafe_arena_release_create_table_space_stmt(); // .pg_query.DropTableSpaceStmt drop_table_space_stmt = 124 [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* drop_table_space_stmt); private: const ::pg_query::DropTableSpaceStmt& _internal_drop_table_space_stmt() const; ::pg_query::DropTableSpaceStmt* _internal_mutable_drop_table_space_stmt(); public: void unsafe_arena_set_allocated_drop_table_space_stmt( ::pg_query::DropTableSpaceStmt* drop_table_space_stmt); ::pg_query::DropTableSpaceStmt* unsafe_arena_release_drop_table_space_stmt(); // .pg_query.AlterObjectDependsStmt alter_object_depends_stmt = 125 [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* alter_object_depends_stmt); private: const ::pg_query::AlterObjectDependsStmt& _internal_alter_object_depends_stmt() const; ::pg_query::AlterObjectDependsStmt* _internal_mutable_alter_object_depends_stmt(); public: void unsafe_arena_set_allocated_alter_object_depends_stmt( ::pg_query::AlterObjectDependsStmt* alter_object_depends_stmt); ::pg_query::AlterObjectDependsStmt* unsafe_arena_release_alter_object_depends_stmt(); // .pg_query.AlterObjectSchemaStmt alter_object_schema_stmt = 126 [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* alter_object_schema_stmt); private: const ::pg_query::AlterObjectSchemaStmt& _internal_alter_object_schema_stmt() const; ::pg_query::AlterObjectSchemaStmt* _internal_mutable_alter_object_schema_stmt(); public: void unsafe_arena_set_allocated_alter_object_schema_stmt( ::pg_query::AlterObjectSchemaStmt* alter_object_schema_stmt); ::pg_query::AlterObjectSchemaStmt* unsafe_arena_release_alter_object_schema_stmt(); // .pg_query.AlterOwnerStmt alter_owner_stmt = 127 [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* alter_owner_stmt); private: const ::pg_query::AlterOwnerStmt& _internal_alter_owner_stmt() const; ::pg_query::AlterOwnerStmt* _internal_mutable_alter_owner_stmt(); public: void unsafe_arena_set_allocated_alter_owner_stmt( ::pg_query::AlterOwnerStmt* alter_owner_stmt); ::pg_query::AlterOwnerStmt* unsafe_arena_release_alter_owner_stmt(); // .pg_query.AlterOperatorStmt alter_operator_stmt = 128 [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* alter_operator_stmt); private: const ::pg_query::AlterOperatorStmt& _internal_alter_operator_stmt() const; ::pg_query::AlterOperatorStmt* _internal_mutable_alter_operator_stmt(); public: void unsafe_arena_set_allocated_alter_operator_stmt( ::pg_query::AlterOperatorStmt* alter_operator_stmt); ::pg_query::AlterOperatorStmt* unsafe_arena_release_alter_operator_stmt(); // .pg_query.AlterTypeStmt alter_type_stmt = 129 [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* alter_type_stmt); private: const ::pg_query::AlterTypeStmt& _internal_alter_type_stmt() const; ::pg_query::AlterTypeStmt* _internal_mutable_alter_type_stmt(); public: void unsafe_arena_set_allocated_alter_type_stmt( ::pg_query::AlterTypeStmt* alter_type_stmt); ::pg_query::AlterTypeStmt* unsafe_arena_release_alter_type_stmt(); // .pg_query.DropOwnedStmt drop_owned_stmt = 130 [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* drop_owned_stmt); private: const ::pg_query::DropOwnedStmt& _internal_drop_owned_stmt() const; ::pg_query::DropOwnedStmt* _internal_mutable_drop_owned_stmt(); public: void unsafe_arena_set_allocated_drop_owned_stmt( ::pg_query::DropOwnedStmt* drop_owned_stmt); ::pg_query::DropOwnedStmt* unsafe_arena_release_drop_owned_stmt(); // .pg_query.ReassignOwnedStmt reassign_owned_stmt = 131 [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* reassign_owned_stmt); private: const ::pg_query::ReassignOwnedStmt& _internal_reassign_owned_stmt() const; ::pg_query::ReassignOwnedStmt* _internal_mutable_reassign_owned_stmt(); public: void unsafe_arena_set_allocated_reassign_owned_stmt( ::pg_query::ReassignOwnedStmt* reassign_owned_stmt); ::pg_query::ReassignOwnedStmt* unsafe_arena_release_reassign_owned_stmt(); // .pg_query.CompositeTypeStmt composite_type_stmt = 132 [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* composite_type_stmt); private: const ::pg_query::CompositeTypeStmt& _internal_composite_type_stmt() const; ::pg_query::CompositeTypeStmt* _internal_mutable_composite_type_stmt(); public: void unsafe_arena_set_allocated_composite_type_stmt( ::pg_query::CompositeTypeStmt* composite_type_stmt); ::pg_query::CompositeTypeStmt* unsafe_arena_release_composite_type_stmt(); // .pg_query.CreateEnumStmt create_enum_stmt = 133 [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* create_enum_stmt); private: const ::pg_query::CreateEnumStmt& _internal_create_enum_stmt() const; ::pg_query::CreateEnumStmt* _internal_mutable_create_enum_stmt(); public: void unsafe_arena_set_allocated_create_enum_stmt( ::pg_query::CreateEnumStmt* create_enum_stmt); ::pg_query::CreateEnumStmt* unsafe_arena_release_create_enum_stmt(); // .pg_query.CreateRangeStmt create_range_stmt = 134 [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* create_range_stmt); private: const ::pg_query::CreateRangeStmt& _internal_create_range_stmt() const; ::pg_query::CreateRangeStmt* _internal_mutable_create_range_stmt(); public: void unsafe_arena_set_allocated_create_range_stmt( ::pg_query::CreateRangeStmt* create_range_stmt); ::pg_query::CreateRangeStmt* unsafe_arena_release_create_range_stmt(); // .pg_query.AlterEnumStmt alter_enum_stmt = 135 [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* alter_enum_stmt); private: const ::pg_query::AlterEnumStmt& _internal_alter_enum_stmt() const; ::pg_query::AlterEnumStmt* _internal_mutable_alter_enum_stmt(); public: void unsafe_arena_set_allocated_alter_enum_stmt( ::pg_query::AlterEnumStmt* alter_enum_stmt); ::pg_query::AlterEnumStmt* unsafe_arena_release_alter_enum_stmt(); // .pg_query.AlterTSDictionaryStmt alter_tsdictionary_stmt = 136 [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* alter_tsdictionary_stmt); private: const ::pg_query::AlterTSDictionaryStmt& _internal_alter_tsdictionary_stmt() const; ::pg_query::AlterTSDictionaryStmt* _internal_mutable_alter_tsdictionary_stmt(); public: void unsafe_arena_set_allocated_alter_tsdictionary_stmt( ::pg_query::AlterTSDictionaryStmt* alter_tsdictionary_stmt); ::pg_query::AlterTSDictionaryStmt* unsafe_arena_release_alter_tsdictionary_stmt(); // .pg_query.AlterTSConfigurationStmt alter_tsconfiguration_stmt = 137 [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* alter_tsconfiguration_stmt); private: const ::pg_query::AlterTSConfigurationStmt& _internal_alter_tsconfiguration_stmt() const; ::pg_query::AlterTSConfigurationStmt* _internal_mutable_alter_tsconfiguration_stmt(); public: void unsafe_arena_set_allocated_alter_tsconfiguration_stmt( ::pg_query::AlterTSConfigurationStmt* alter_tsconfiguration_stmt); ::pg_query::AlterTSConfigurationStmt* unsafe_arena_release_alter_tsconfiguration_stmt(); // .pg_query.CreateFdwStmt create_fdw_stmt = 138 [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* create_fdw_stmt); private: const ::pg_query::CreateFdwStmt& _internal_create_fdw_stmt() const; ::pg_query::CreateFdwStmt* _internal_mutable_create_fdw_stmt(); public: void unsafe_arena_set_allocated_create_fdw_stmt( ::pg_query::CreateFdwStmt* create_fdw_stmt); ::pg_query::CreateFdwStmt* unsafe_arena_release_create_fdw_stmt(); // .pg_query.AlterFdwStmt alter_fdw_stmt = 139 [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* alter_fdw_stmt); private: const ::pg_query::AlterFdwStmt& _internal_alter_fdw_stmt() const; ::pg_query::AlterFdwStmt* _internal_mutable_alter_fdw_stmt(); public: void unsafe_arena_set_allocated_alter_fdw_stmt( ::pg_query::AlterFdwStmt* alter_fdw_stmt); ::pg_query::AlterFdwStmt* unsafe_arena_release_alter_fdw_stmt(); // .pg_query.CreateForeignServerStmt create_foreign_server_stmt = 140 [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* create_foreign_server_stmt); private: const ::pg_query::CreateForeignServerStmt& _internal_create_foreign_server_stmt() const; ::pg_query::CreateForeignServerStmt* _internal_mutable_create_foreign_server_stmt(); public: void unsafe_arena_set_allocated_create_foreign_server_stmt( ::pg_query::CreateForeignServerStmt* create_foreign_server_stmt); ::pg_query::CreateForeignServerStmt* unsafe_arena_release_create_foreign_server_stmt(); // .pg_query.AlterForeignServerStmt alter_foreign_server_stmt = 141 [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* alter_foreign_server_stmt); private: const ::pg_query::AlterForeignServerStmt& _internal_alter_foreign_server_stmt() const; ::pg_query::AlterForeignServerStmt* _internal_mutable_alter_foreign_server_stmt(); public: void unsafe_arena_set_allocated_alter_foreign_server_stmt( ::pg_query::AlterForeignServerStmt* alter_foreign_server_stmt); ::pg_query::AlterForeignServerStmt* unsafe_arena_release_alter_foreign_server_stmt(); // .pg_query.CreateUserMappingStmt create_user_mapping_stmt = 142 [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* create_user_mapping_stmt); private: const ::pg_query::CreateUserMappingStmt& _internal_create_user_mapping_stmt() const; ::pg_query::CreateUserMappingStmt* _internal_mutable_create_user_mapping_stmt(); public: void unsafe_arena_set_allocated_create_user_mapping_stmt( ::pg_query::CreateUserMappingStmt* create_user_mapping_stmt); ::pg_query::CreateUserMappingStmt* unsafe_arena_release_create_user_mapping_stmt(); // .pg_query.AlterUserMappingStmt alter_user_mapping_stmt = 143 [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* alter_user_mapping_stmt); private: const ::pg_query::AlterUserMappingStmt& _internal_alter_user_mapping_stmt() const; ::pg_query::AlterUserMappingStmt* _internal_mutable_alter_user_mapping_stmt(); public: void unsafe_arena_set_allocated_alter_user_mapping_stmt( ::pg_query::AlterUserMappingStmt* alter_user_mapping_stmt); ::pg_query::AlterUserMappingStmt* unsafe_arena_release_alter_user_mapping_stmt(); // .pg_query.DropUserMappingStmt drop_user_mapping_stmt = 144 [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* drop_user_mapping_stmt); private: const ::pg_query::DropUserMappingStmt& _internal_drop_user_mapping_stmt() const; ::pg_query::DropUserMappingStmt* _internal_mutable_drop_user_mapping_stmt(); public: void unsafe_arena_set_allocated_drop_user_mapping_stmt( ::pg_query::DropUserMappingStmt* drop_user_mapping_stmt); ::pg_query::DropUserMappingStmt* unsafe_arena_release_drop_user_mapping_stmt(); // .pg_query.AlterTableSpaceOptionsStmt alter_table_space_options_stmt = 145 [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* alter_table_space_options_stmt); private: const ::pg_query::AlterTableSpaceOptionsStmt& _internal_alter_table_space_options_stmt() const; ::pg_query::AlterTableSpaceOptionsStmt* _internal_mutable_alter_table_space_options_stmt(); public: void unsafe_arena_set_allocated_alter_table_space_options_stmt( ::pg_query::AlterTableSpaceOptionsStmt* alter_table_space_options_stmt); ::pg_query::AlterTableSpaceOptionsStmt* unsafe_arena_release_alter_table_space_options_stmt(); // .pg_query.AlterTableMoveAllStmt alter_table_move_all_stmt = 146 [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* alter_table_move_all_stmt); private: const ::pg_query::AlterTableMoveAllStmt& _internal_alter_table_move_all_stmt() const; ::pg_query::AlterTableMoveAllStmt* _internal_mutable_alter_table_move_all_stmt(); public: void unsafe_arena_set_allocated_alter_table_move_all_stmt( ::pg_query::AlterTableMoveAllStmt* alter_table_move_all_stmt); ::pg_query::AlterTableMoveAllStmt* unsafe_arena_release_alter_table_move_all_stmt(); // .pg_query.SecLabelStmt sec_label_stmt = 147 [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* sec_label_stmt); private: const ::pg_query::SecLabelStmt& _internal_sec_label_stmt() const; ::pg_query::SecLabelStmt* _internal_mutable_sec_label_stmt(); public: void unsafe_arena_set_allocated_sec_label_stmt( ::pg_query::SecLabelStmt* sec_label_stmt); ::pg_query::SecLabelStmt* unsafe_arena_release_sec_label_stmt(); // .pg_query.CreateForeignTableStmt create_foreign_table_stmt = 148 [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* create_foreign_table_stmt); private: const ::pg_query::CreateForeignTableStmt& _internal_create_foreign_table_stmt() const; ::pg_query::CreateForeignTableStmt* _internal_mutable_create_foreign_table_stmt(); public: void unsafe_arena_set_allocated_create_foreign_table_stmt( ::pg_query::CreateForeignTableStmt* create_foreign_table_stmt); ::pg_query::CreateForeignTableStmt* unsafe_arena_release_create_foreign_table_stmt(); // .pg_query.ImportForeignSchemaStmt import_foreign_schema_stmt = 149 [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* import_foreign_schema_stmt); private: const ::pg_query::ImportForeignSchemaStmt& _internal_import_foreign_schema_stmt() const; ::pg_query::ImportForeignSchemaStmt* _internal_mutable_import_foreign_schema_stmt(); public: void unsafe_arena_set_allocated_import_foreign_schema_stmt( ::pg_query::ImportForeignSchemaStmt* import_foreign_schema_stmt); ::pg_query::ImportForeignSchemaStmt* unsafe_arena_release_import_foreign_schema_stmt(); // .pg_query.CreateExtensionStmt create_extension_stmt = 150 [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* create_extension_stmt); private: const ::pg_query::CreateExtensionStmt& _internal_create_extension_stmt() const; ::pg_query::CreateExtensionStmt* _internal_mutable_create_extension_stmt(); public: void unsafe_arena_set_allocated_create_extension_stmt( ::pg_query::CreateExtensionStmt* create_extension_stmt); ::pg_query::CreateExtensionStmt* unsafe_arena_release_create_extension_stmt(); // .pg_query.AlterExtensionStmt alter_extension_stmt = 151 [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* alter_extension_stmt); private: const ::pg_query::AlterExtensionStmt& _internal_alter_extension_stmt() const; ::pg_query::AlterExtensionStmt* _internal_mutable_alter_extension_stmt(); public: void unsafe_arena_set_allocated_alter_extension_stmt( ::pg_query::AlterExtensionStmt* alter_extension_stmt); ::pg_query::AlterExtensionStmt* unsafe_arena_release_alter_extension_stmt(); // .pg_query.AlterExtensionContentsStmt alter_extension_contents_stmt = 152 [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* alter_extension_contents_stmt); private: const ::pg_query::AlterExtensionContentsStmt& _internal_alter_extension_contents_stmt() const; ::pg_query::AlterExtensionContentsStmt* _internal_mutable_alter_extension_contents_stmt(); public: void unsafe_arena_set_allocated_alter_extension_contents_stmt( ::pg_query::AlterExtensionContentsStmt* alter_extension_contents_stmt); ::pg_query::AlterExtensionContentsStmt* unsafe_arena_release_alter_extension_contents_stmt(); // .pg_query.CreateEventTrigStmt create_event_trig_stmt = 153 [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* create_event_trig_stmt); private: const ::pg_query::CreateEventTrigStmt& _internal_create_event_trig_stmt() const; ::pg_query::CreateEventTrigStmt* _internal_mutable_create_event_trig_stmt(); public: void unsafe_arena_set_allocated_create_event_trig_stmt( ::pg_query::CreateEventTrigStmt* create_event_trig_stmt); ::pg_query::CreateEventTrigStmt* unsafe_arena_release_create_event_trig_stmt(); // .pg_query.AlterEventTrigStmt alter_event_trig_stmt = 154 [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* alter_event_trig_stmt); private: const ::pg_query::AlterEventTrigStmt& _internal_alter_event_trig_stmt() const; ::pg_query::AlterEventTrigStmt* _internal_mutable_alter_event_trig_stmt(); public: void unsafe_arena_set_allocated_alter_event_trig_stmt( ::pg_query::AlterEventTrigStmt* alter_event_trig_stmt); ::pg_query::AlterEventTrigStmt* unsafe_arena_release_alter_event_trig_stmt(); // .pg_query.RefreshMatViewStmt refresh_mat_view_stmt = 155 [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* refresh_mat_view_stmt); private: const ::pg_query::RefreshMatViewStmt& _internal_refresh_mat_view_stmt() const; ::pg_query::RefreshMatViewStmt* _internal_mutable_refresh_mat_view_stmt(); public: void unsafe_arena_set_allocated_refresh_mat_view_stmt( ::pg_query::RefreshMatViewStmt* refresh_mat_view_stmt); ::pg_query::RefreshMatViewStmt* unsafe_arena_release_refresh_mat_view_stmt(); // .pg_query.ReplicaIdentityStmt replica_identity_stmt = 156 [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* replica_identity_stmt); private: const ::pg_query::ReplicaIdentityStmt& _internal_replica_identity_stmt() const; ::pg_query::ReplicaIdentityStmt* _internal_mutable_replica_identity_stmt(); public: void unsafe_arena_set_allocated_replica_identity_stmt( ::pg_query::ReplicaIdentityStmt* replica_identity_stmt); ::pg_query::ReplicaIdentityStmt* unsafe_arena_release_replica_identity_stmt(); // .pg_query.AlterSystemStmt alter_system_stmt = 157 [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* alter_system_stmt); private: const ::pg_query::AlterSystemStmt& _internal_alter_system_stmt() const; ::pg_query::AlterSystemStmt* _internal_mutable_alter_system_stmt(); public: void unsafe_arena_set_allocated_alter_system_stmt( ::pg_query::AlterSystemStmt* alter_system_stmt); ::pg_query::AlterSystemStmt* unsafe_arena_release_alter_system_stmt(); // .pg_query.CreatePolicyStmt create_policy_stmt = 158 [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* create_policy_stmt); private: const ::pg_query::CreatePolicyStmt& _internal_create_policy_stmt() const; ::pg_query::CreatePolicyStmt* _internal_mutable_create_policy_stmt(); public: void unsafe_arena_set_allocated_create_policy_stmt( ::pg_query::CreatePolicyStmt* create_policy_stmt); ::pg_query::CreatePolicyStmt* unsafe_arena_release_create_policy_stmt(); // .pg_query.AlterPolicyStmt alter_policy_stmt = 159 [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* alter_policy_stmt); private: const ::pg_query::AlterPolicyStmt& _internal_alter_policy_stmt() const; ::pg_query::AlterPolicyStmt* _internal_mutable_alter_policy_stmt(); public: void unsafe_arena_set_allocated_alter_policy_stmt( ::pg_query::AlterPolicyStmt* alter_policy_stmt); ::pg_query::AlterPolicyStmt* unsafe_arena_release_alter_policy_stmt(); // .pg_query.CreateTransformStmt create_transform_stmt = 160 [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* create_transform_stmt); private: const ::pg_query::CreateTransformStmt& _internal_create_transform_stmt() const; ::pg_query::CreateTransformStmt* _internal_mutable_create_transform_stmt(); public: void unsafe_arena_set_allocated_create_transform_stmt( ::pg_query::CreateTransformStmt* create_transform_stmt); ::pg_query::CreateTransformStmt* unsafe_arena_release_create_transform_stmt(); // .pg_query.CreateAmStmt create_am_stmt = 161 [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* create_am_stmt); private: const ::pg_query::CreateAmStmt& _internal_create_am_stmt() const; ::pg_query::CreateAmStmt* _internal_mutable_create_am_stmt(); public: void unsafe_arena_set_allocated_create_am_stmt( ::pg_query::CreateAmStmt* create_am_stmt); ::pg_query::CreateAmStmt* unsafe_arena_release_create_am_stmt(); // .pg_query.CreatePublicationStmt create_publication_stmt = 162 [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* create_publication_stmt); private: const ::pg_query::CreatePublicationStmt& _internal_create_publication_stmt() const; ::pg_query::CreatePublicationStmt* _internal_mutable_create_publication_stmt(); public: void unsafe_arena_set_allocated_create_publication_stmt( ::pg_query::CreatePublicationStmt* create_publication_stmt); ::pg_query::CreatePublicationStmt* unsafe_arena_release_create_publication_stmt(); // .pg_query.AlterPublicationStmt alter_publication_stmt = 163 [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* alter_publication_stmt); private: const ::pg_query::AlterPublicationStmt& _internal_alter_publication_stmt() const; ::pg_query::AlterPublicationStmt* _internal_mutable_alter_publication_stmt(); public: void unsafe_arena_set_allocated_alter_publication_stmt( ::pg_query::AlterPublicationStmt* alter_publication_stmt); ::pg_query::AlterPublicationStmt* unsafe_arena_release_alter_publication_stmt(); // .pg_query.CreateSubscriptionStmt create_subscription_stmt = 164 [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* create_subscription_stmt); private: const ::pg_query::CreateSubscriptionStmt& _internal_create_subscription_stmt() const; ::pg_query::CreateSubscriptionStmt* _internal_mutable_create_subscription_stmt(); public: void unsafe_arena_set_allocated_create_subscription_stmt( ::pg_query::CreateSubscriptionStmt* create_subscription_stmt); ::pg_query::CreateSubscriptionStmt* unsafe_arena_release_create_subscription_stmt(); // .pg_query.AlterSubscriptionStmt alter_subscription_stmt = 165 [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* alter_subscription_stmt); private: const ::pg_query::AlterSubscriptionStmt& _internal_alter_subscription_stmt() const; ::pg_query::AlterSubscriptionStmt* _internal_mutable_alter_subscription_stmt(); public: void unsafe_arena_set_allocated_alter_subscription_stmt( ::pg_query::AlterSubscriptionStmt* alter_subscription_stmt); ::pg_query::AlterSubscriptionStmt* unsafe_arena_release_alter_subscription_stmt(); // .pg_query.DropSubscriptionStmt drop_subscription_stmt = 166 [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* drop_subscription_stmt); private: const ::pg_query::DropSubscriptionStmt& _internal_drop_subscription_stmt() const; ::pg_query::DropSubscriptionStmt* _internal_mutable_drop_subscription_stmt(); public: void unsafe_arena_set_allocated_drop_subscription_stmt( ::pg_query::DropSubscriptionStmt* drop_subscription_stmt); ::pg_query::DropSubscriptionStmt* unsafe_arena_release_drop_subscription_stmt(); // .pg_query.CreateStatsStmt create_stats_stmt = 167 [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* create_stats_stmt); private: const ::pg_query::CreateStatsStmt& _internal_create_stats_stmt() const; ::pg_query::CreateStatsStmt* _internal_mutable_create_stats_stmt(); public: void unsafe_arena_set_allocated_create_stats_stmt( ::pg_query::CreateStatsStmt* create_stats_stmt); ::pg_query::CreateStatsStmt* unsafe_arena_release_create_stats_stmt(); // .pg_query.AlterCollationStmt alter_collation_stmt = 168 [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* alter_collation_stmt); private: const ::pg_query::AlterCollationStmt& _internal_alter_collation_stmt() const; ::pg_query::AlterCollationStmt* _internal_mutable_alter_collation_stmt(); public: void unsafe_arena_set_allocated_alter_collation_stmt( ::pg_query::AlterCollationStmt* alter_collation_stmt); ::pg_query::AlterCollationStmt* unsafe_arena_release_alter_collation_stmt(); // .pg_query.CallStmt call_stmt = 169 [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* call_stmt); private: const ::pg_query::CallStmt& _internal_call_stmt() const; ::pg_query::CallStmt* _internal_mutable_call_stmt(); public: void unsafe_arena_set_allocated_call_stmt( ::pg_query::CallStmt* call_stmt); ::pg_query::CallStmt* unsafe_arena_release_call_stmt(); // .pg_query.AlterStatsStmt alter_stats_stmt = 170 [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* alter_stats_stmt); private: const ::pg_query::AlterStatsStmt& _internal_alter_stats_stmt() const; ::pg_query::AlterStatsStmt* _internal_mutable_alter_stats_stmt(); public: void unsafe_arena_set_allocated_alter_stats_stmt( ::pg_query::AlterStatsStmt* alter_stats_stmt); ::pg_query::AlterStatsStmt* unsafe_arena_release_alter_stats_stmt(); // .pg_query.A_Expr a_expr = 171 [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* a_expr); private: const ::pg_query::A_Expr& _internal_a_expr() const; ::pg_query::A_Expr* _internal_mutable_a_expr(); public: void unsafe_arena_set_allocated_a_expr( ::pg_query::A_Expr* a_expr); ::pg_query::A_Expr* unsafe_arena_release_a_expr(); // .pg_query.ColumnRef column_ref = 172 [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* column_ref); private: const ::pg_query::ColumnRef& _internal_column_ref() const; ::pg_query::ColumnRef* _internal_mutable_column_ref(); public: void unsafe_arena_set_allocated_column_ref( ::pg_query::ColumnRef* column_ref); ::pg_query::ColumnRef* unsafe_arena_release_column_ref(); // .pg_query.ParamRef param_ref = 173 [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* param_ref); private: const ::pg_query::ParamRef& _internal_param_ref() const; ::pg_query::ParamRef* _internal_mutable_param_ref(); public: void unsafe_arena_set_allocated_param_ref( ::pg_query::ParamRef* param_ref); ::pg_query::ParamRef* unsafe_arena_release_param_ref(); // .pg_query.FuncCall func_call = 174 [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* func_call); private: const ::pg_query::FuncCall& _internal_func_call() const; ::pg_query::FuncCall* _internal_mutable_func_call(); public: void unsafe_arena_set_allocated_func_call( ::pg_query::FuncCall* func_call); ::pg_query::FuncCall* unsafe_arena_release_func_call(); // .pg_query.A_Star a_star = 175 [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* a_star); private: const ::pg_query::A_Star& _internal_a_star() const; ::pg_query::A_Star* _internal_mutable_a_star(); public: void unsafe_arena_set_allocated_a_star( ::pg_query::A_Star* a_star); ::pg_query::A_Star* unsafe_arena_release_a_star(); // .pg_query.A_Indices a_indices = 176 [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* a_indices); private: const ::pg_query::A_Indices& _internal_a_indices() const; ::pg_query::A_Indices* _internal_mutable_a_indices(); public: void unsafe_arena_set_allocated_a_indices( ::pg_query::A_Indices* a_indices); ::pg_query::A_Indices* unsafe_arena_release_a_indices(); // .pg_query.A_Indirection a_indirection = 177 [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* a_indirection); private: const ::pg_query::A_Indirection& _internal_a_indirection() const; ::pg_query::A_Indirection* _internal_mutable_a_indirection(); public: void unsafe_arena_set_allocated_a_indirection( ::pg_query::A_Indirection* a_indirection); ::pg_query::A_Indirection* unsafe_arena_release_a_indirection(); // .pg_query.A_ArrayExpr a_array_expr = 178 [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* a_array_expr); private: const ::pg_query::A_ArrayExpr& _internal_a_array_expr() const; ::pg_query::A_ArrayExpr* _internal_mutable_a_array_expr(); public: void unsafe_arena_set_allocated_a_array_expr( ::pg_query::A_ArrayExpr* a_array_expr); ::pg_query::A_ArrayExpr* unsafe_arena_release_a_array_expr(); // .pg_query.ResTarget res_target = 179 [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* res_target); private: const ::pg_query::ResTarget& _internal_res_target() const; ::pg_query::ResTarget* _internal_mutable_res_target(); public: void unsafe_arena_set_allocated_res_target( ::pg_query::ResTarget* res_target); ::pg_query::ResTarget* unsafe_arena_release_res_target(); // .pg_query.MultiAssignRef multi_assign_ref = 180 [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* multi_assign_ref); private: const ::pg_query::MultiAssignRef& _internal_multi_assign_ref() const; ::pg_query::MultiAssignRef* _internal_mutable_multi_assign_ref(); public: void unsafe_arena_set_allocated_multi_assign_ref( ::pg_query::MultiAssignRef* multi_assign_ref); ::pg_query::MultiAssignRef* unsafe_arena_release_multi_assign_ref(); // .pg_query.TypeCast type_cast = 181 [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* type_cast); private: const ::pg_query::TypeCast& _internal_type_cast() const; ::pg_query::TypeCast* _internal_mutable_type_cast(); public: void unsafe_arena_set_allocated_type_cast( ::pg_query::TypeCast* type_cast); ::pg_query::TypeCast* unsafe_arena_release_type_cast(); // .pg_query.CollateClause collate_clause = 182 [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* collate_clause); private: const ::pg_query::CollateClause& _internal_collate_clause() const; ::pg_query::CollateClause* _internal_mutable_collate_clause(); public: void unsafe_arena_set_allocated_collate_clause( ::pg_query::CollateClause* collate_clause); ::pg_query::CollateClause* unsafe_arena_release_collate_clause(); // .pg_query.SortBy sort_by = 183 [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* sort_by); private: const ::pg_query::SortBy& _internal_sort_by() const; ::pg_query::SortBy* _internal_mutable_sort_by(); public: void unsafe_arena_set_allocated_sort_by( ::pg_query::SortBy* sort_by); ::pg_query::SortBy* unsafe_arena_release_sort_by(); // .pg_query.WindowDef window_def = 184 [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* window_def); private: const ::pg_query::WindowDef& _internal_window_def() const; ::pg_query::WindowDef* _internal_mutable_window_def(); public: void unsafe_arena_set_allocated_window_def( ::pg_query::WindowDef* window_def); ::pg_query::WindowDef* unsafe_arena_release_window_def(); // .pg_query.RangeSubselect range_subselect = 185 [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* range_subselect); private: const ::pg_query::RangeSubselect& _internal_range_subselect() const; ::pg_query::RangeSubselect* _internal_mutable_range_subselect(); public: void unsafe_arena_set_allocated_range_subselect( ::pg_query::RangeSubselect* range_subselect); ::pg_query::RangeSubselect* unsafe_arena_release_range_subselect(); // .pg_query.RangeFunction range_function = 186 [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* range_function); private: const ::pg_query::RangeFunction& _internal_range_function() const; ::pg_query::RangeFunction* _internal_mutable_range_function(); public: void unsafe_arena_set_allocated_range_function( ::pg_query::RangeFunction* range_function); ::pg_query::RangeFunction* unsafe_arena_release_range_function(); // .pg_query.RangeTableSample range_table_sample = 187 [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* range_table_sample); private: const ::pg_query::RangeTableSample& _internal_range_table_sample() const; ::pg_query::RangeTableSample* _internal_mutable_range_table_sample(); public: void unsafe_arena_set_allocated_range_table_sample( ::pg_query::RangeTableSample* range_table_sample); ::pg_query::RangeTableSample* unsafe_arena_release_range_table_sample(); // .pg_query.RangeTableFunc range_table_func = 188 [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* range_table_func); private: const ::pg_query::RangeTableFunc& _internal_range_table_func() const; ::pg_query::RangeTableFunc* _internal_mutable_range_table_func(); public: void unsafe_arena_set_allocated_range_table_func( ::pg_query::RangeTableFunc* range_table_func); ::pg_query::RangeTableFunc* unsafe_arena_release_range_table_func(); // .pg_query.RangeTableFuncCol range_table_func_col = 189 [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* range_table_func_col); private: const ::pg_query::RangeTableFuncCol& _internal_range_table_func_col() const; ::pg_query::RangeTableFuncCol* _internal_mutable_range_table_func_col(); public: void unsafe_arena_set_allocated_range_table_func_col( ::pg_query::RangeTableFuncCol* range_table_func_col); ::pg_query::RangeTableFuncCol* unsafe_arena_release_range_table_func_col(); // .pg_query.TypeName type_name = 190 [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* type_name); private: const ::pg_query::TypeName& _internal_type_name() const; ::pg_query::TypeName* _internal_mutable_type_name(); public: void unsafe_arena_set_allocated_type_name( ::pg_query::TypeName* type_name); ::pg_query::TypeName* unsafe_arena_release_type_name(); // .pg_query.ColumnDef column_def = 191 [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* column_def); private: const ::pg_query::ColumnDef& _internal_column_def() const; ::pg_query::ColumnDef* _internal_mutable_column_def(); public: void unsafe_arena_set_allocated_column_def( ::pg_query::ColumnDef* column_def); ::pg_query::ColumnDef* unsafe_arena_release_column_def(); // .pg_query.IndexElem index_elem = 192 [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* index_elem); private: const ::pg_query::IndexElem& _internal_index_elem() const; ::pg_query::IndexElem* _internal_mutable_index_elem(); public: void unsafe_arena_set_allocated_index_elem( ::pg_query::IndexElem* index_elem); ::pg_query::IndexElem* unsafe_arena_release_index_elem(); // .pg_query.StatsElem stats_elem = 193 [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* stats_elem); private: const ::pg_query::StatsElem& _internal_stats_elem() const; ::pg_query::StatsElem* _internal_mutable_stats_elem(); public: void unsafe_arena_set_allocated_stats_elem( ::pg_query::StatsElem* stats_elem); ::pg_query::StatsElem* unsafe_arena_release_stats_elem(); // .pg_query.Constraint constraint = 194 [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* constraint); private: const ::pg_query::Constraint& _internal_constraint() const; ::pg_query::Constraint* _internal_mutable_constraint(); public: void unsafe_arena_set_allocated_constraint( ::pg_query::Constraint* constraint); ::pg_query::Constraint* unsafe_arena_release_constraint(); // .pg_query.DefElem def_elem = 195 [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* def_elem); private: const ::pg_query::DefElem& _internal_def_elem() const; ::pg_query::DefElem* _internal_mutable_def_elem(); public: void unsafe_arena_set_allocated_def_elem( ::pg_query::DefElem* def_elem); ::pg_query::DefElem* unsafe_arena_release_def_elem(); // .pg_query.RangeTblEntry range_tbl_entry = 196 [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* range_tbl_entry); private: const ::pg_query::RangeTblEntry& _internal_range_tbl_entry() const; ::pg_query::RangeTblEntry* _internal_mutable_range_tbl_entry(); public: void unsafe_arena_set_allocated_range_tbl_entry( ::pg_query::RangeTblEntry* range_tbl_entry); ::pg_query::RangeTblEntry* unsafe_arena_release_range_tbl_entry(); // .pg_query.RangeTblFunction range_tbl_function = 197 [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* range_tbl_function); private: const ::pg_query::RangeTblFunction& _internal_range_tbl_function() const; ::pg_query::RangeTblFunction* _internal_mutable_range_tbl_function(); public: void unsafe_arena_set_allocated_range_tbl_function( ::pg_query::RangeTblFunction* range_tbl_function); ::pg_query::RangeTblFunction* unsafe_arena_release_range_tbl_function(); // .pg_query.TableSampleClause table_sample_clause = 198 [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* table_sample_clause); private: const ::pg_query::TableSampleClause& _internal_table_sample_clause() const; ::pg_query::TableSampleClause* _internal_mutable_table_sample_clause(); public: void unsafe_arena_set_allocated_table_sample_clause( ::pg_query::TableSampleClause* table_sample_clause); ::pg_query::TableSampleClause* unsafe_arena_release_table_sample_clause(); // .pg_query.WithCheckOption with_check_option = 199 [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* with_check_option); private: const ::pg_query::WithCheckOption& _internal_with_check_option() const; ::pg_query::WithCheckOption* _internal_mutable_with_check_option(); public: void unsafe_arena_set_allocated_with_check_option( ::pg_query::WithCheckOption* with_check_option); ::pg_query::WithCheckOption* unsafe_arena_release_with_check_option(); // .pg_query.SortGroupClause sort_group_clause = 200 [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* sort_group_clause); private: const ::pg_query::SortGroupClause& _internal_sort_group_clause() const; ::pg_query::SortGroupClause* _internal_mutable_sort_group_clause(); public: void unsafe_arena_set_allocated_sort_group_clause( ::pg_query::SortGroupClause* sort_group_clause); ::pg_query::SortGroupClause* unsafe_arena_release_sort_group_clause(); // .pg_query.GroupingSet grouping_set = 201 [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* grouping_set); private: const ::pg_query::GroupingSet& _internal_grouping_set() const; ::pg_query::GroupingSet* _internal_mutable_grouping_set(); public: void unsafe_arena_set_allocated_grouping_set( ::pg_query::GroupingSet* grouping_set); ::pg_query::GroupingSet* unsafe_arena_release_grouping_set(); // .pg_query.WindowClause window_clause = 202 [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* window_clause); private: const ::pg_query::WindowClause& _internal_window_clause() const; ::pg_query::WindowClause* _internal_mutable_window_clause(); public: void unsafe_arena_set_allocated_window_clause( ::pg_query::WindowClause* window_clause); ::pg_query::WindowClause* unsafe_arena_release_window_clause(); // .pg_query.ObjectWithArgs object_with_args = 203 [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* object_with_args); private: const ::pg_query::ObjectWithArgs& _internal_object_with_args() const; ::pg_query::ObjectWithArgs* _internal_mutable_object_with_args(); public: void unsafe_arena_set_allocated_object_with_args( ::pg_query::ObjectWithArgs* object_with_args); ::pg_query::ObjectWithArgs* unsafe_arena_release_object_with_args(); // .pg_query.AccessPriv access_priv = 204 [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* access_priv); private: const ::pg_query::AccessPriv& _internal_access_priv() const; ::pg_query::AccessPriv* _internal_mutable_access_priv(); public: void unsafe_arena_set_allocated_access_priv( ::pg_query::AccessPriv* access_priv); ::pg_query::AccessPriv* unsafe_arena_release_access_priv(); // .pg_query.CreateOpClassItem create_op_class_item = 205 [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* create_op_class_item); private: const ::pg_query::CreateOpClassItem& _internal_create_op_class_item() const; ::pg_query::CreateOpClassItem* _internal_mutable_create_op_class_item(); public: void unsafe_arena_set_allocated_create_op_class_item( ::pg_query::CreateOpClassItem* create_op_class_item); ::pg_query::CreateOpClassItem* unsafe_arena_release_create_op_class_item(); // .pg_query.TableLikeClause table_like_clause = 206 [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* table_like_clause); private: const ::pg_query::TableLikeClause& _internal_table_like_clause() const; ::pg_query::TableLikeClause* _internal_mutable_table_like_clause(); public: void unsafe_arena_set_allocated_table_like_clause( ::pg_query::TableLikeClause* table_like_clause); ::pg_query::TableLikeClause* unsafe_arena_release_table_like_clause(); // .pg_query.FunctionParameter function_parameter = 207 [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* function_parameter); private: const ::pg_query::FunctionParameter& _internal_function_parameter() const; ::pg_query::FunctionParameter* _internal_mutable_function_parameter(); public: void unsafe_arena_set_allocated_function_parameter( ::pg_query::FunctionParameter* function_parameter); ::pg_query::FunctionParameter* unsafe_arena_release_function_parameter(); // .pg_query.LockingClause locking_clause = 208 [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* locking_clause); private: const ::pg_query::LockingClause& _internal_locking_clause() const; ::pg_query::LockingClause* _internal_mutable_locking_clause(); public: void unsafe_arena_set_allocated_locking_clause( ::pg_query::LockingClause* locking_clause); ::pg_query::LockingClause* unsafe_arena_release_locking_clause(); // .pg_query.RowMarkClause row_mark_clause = 209 [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* row_mark_clause); private: const ::pg_query::RowMarkClause& _internal_row_mark_clause() const; ::pg_query::RowMarkClause* _internal_mutable_row_mark_clause(); public: void unsafe_arena_set_allocated_row_mark_clause( ::pg_query::RowMarkClause* row_mark_clause); ::pg_query::RowMarkClause* unsafe_arena_release_row_mark_clause(); // .pg_query.XmlSerialize xml_serialize = 210 [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* xml_serialize); private: const ::pg_query::XmlSerialize& _internal_xml_serialize() const; ::pg_query::XmlSerialize* _internal_mutable_xml_serialize(); public: void unsafe_arena_set_allocated_xml_serialize( ::pg_query::XmlSerialize* xml_serialize); ::pg_query::XmlSerialize* unsafe_arena_release_xml_serialize(); // .pg_query.WithClause with_clause = 211 [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* with_clause); private: const ::pg_query::WithClause& _internal_with_clause() const; ::pg_query::WithClause* _internal_mutable_with_clause(); public: void unsafe_arena_set_allocated_with_clause( ::pg_query::WithClause* with_clause); ::pg_query::WithClause* unsafe_arena_release_with_clause(); // .pg_query.InferClause infer_clause = 212 [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* infer_clause); private: const ::pg_query::InferClause& _internal_infer_clause() const; ::pg_query::InferClause* _internal_mutable_infer_clause(); public: void unsafe_arena_set_allocated_infer_clause( ::pg_query::InferClause* infer_clause); ::pg_query::InferClause* unsafe_arena_release_infer_clause(); // .pg_query.OnConflictClause on_conflict_clause = 213 [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* on_conflict_clause); private: const ::pg_query::OnConflictClause& _internal_on_conflict_clause() const; ::pg_query::OnConflictClause* _internal_mutable_on_conflict_clause(); public: void unsafe_arena_set_allocated_on_conflict_clause( ::pg_query::OnConflictClause* on_conflict_clause); ::pg_query::OnConflictClause* unsafe_arena_release_on_conflict_clause(); // .pg_query.CTESearchClause ctesearch_clause = 214 [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* ctesearch_clause); private: const ::pg_query::CTESearchClause& _internal_ctesearch_clause() const; ::pg_query::CTESearchClause* _internal_mutable_ctesearch_clause(); public: void unsafe_arena_set_allocated_ctesearch_clause( ::pg_query::CTESearchClause* ctesearch_clause); ::pg_query::CTESearchClause* unsafe_arena_release_ctesearch_clause(); // .pg_query.CTECycleClause ctecycle_clause = 215 [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* ctecycle_clause); private: const ::pg_query::CTECycleClause& _internal_ctecycle_clause() const; ::pg_query::CTECycleClause* _internal_mutable_ctecycle_clause(); public: void unsafe_arena_set_allocated_ctecycle_clause( ::pg_query::CTECycleClause* ctecycle_clause); ::pg_query::CTECycleClause* unsafe_arena_release_ctecycle_clause(); // .pg_query.CommonTableExpr common_table_expr = 216 [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* common_table_expr); private: const ::pg_query::CommonTableExpr& _internal_common_table_expr() const; ::pg_query::CommonTableExpr* _internal_mutable_common_table_expr(); public: void unsafe_arena_set_allocated_common_table_expr( ::pg_query::CommonTableExpr* common_table_expr); ::pg_query::CommonTableExpr* unsafe_arena_release_common_table_expr(); // .pg_query.MergeWhenClause merge_when_clause = 217 [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* merge_when_clause); private: const ::pg_query::MergeWhenClause& _internal_merge_when_clause() const; ::pg_query::MergeWhenClause* _internal_mutable_merge_when_clause(); public: void unsafe_arena_set_allocated_merge_when_clause( ::pg_query::MergeWhenClause* merge_when_clause); ::pg_query::MergeWhenClause* unsafe_arena_release_merge_when_clause(); // .pg_query.RoleSpec role_spec = 218 [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* role_spec); private: const ::pg_query::RoleSpec& _internal_role_spec() const; ::pg_query::RoleSpec* _internal_mutable_role_spec(); public: void unsafe_arena_set_allocated_role_spec( ::pg_query::RoleSpec* role_spec); ::pg_query::RoleSpec* unsafe_arena_release_role_spec(); // .pg_query.TriggerTransition trigger_transition = 219 [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* trigger_transition); private: const ::pg_query::TriggerTransition& _internal_trigger_transition() const; ::pg_query::TriggerTransition* _internal_mutable_trigger_transition(); public: void unsafe_arena_set_allocated_trigger_transition( ::pg_query::TriggerTransition* trigger_transition); ::pg_query::TriggerTransition* unsafe_arena_release_trigger_transition(); // .pg_query.PartitionElem partition_elem = 220 [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* partition_elem); private: const ::pg_query::PartitionElem& _internal_partition_elem() const; ::pg_query::PartitionElem* _internal_mutable_partition_elem(); public: void unsafe_arena_set_allocated_partition_elem( ::pg_query::PartitionElem* partition_elem); ::pg_query::PartitionElem* unsafe_arena_release_partition_elem(); // .pg_query.PartitionSpec partition_spec = 221 [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* partition_spec); private: const ::pg_query::PartitionSpec& _internal_partition_spec() const; ::pg_query::PartitionSpec* _internal_mutable_partition_spec(); public: void unsafe_arena_set_allocated_partition_spec( ::pg_query::PartitionSpec* partition_spec); ::pg_query::PartitionSpec* unsafe_arena_release_partition_spec(); // .pg_query.PartitionBoundSpec partition_bound_spec = 222 [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* partition_bound_spec); private: const ::pg_query::PartitionBoundSpec& _internal_partition_bound_spec() const; ::pg_query::PartitionBoundSpec* _internal_mutable_partition_bound_spec(); public: void unsafe_arena_set_allocated_partition_bound_spec( ::pg_query::PartitionBoundSpec* partition_bound_spec); ::pg_query::PartitionBoundSpec* unsafe_arena_release_partition_bound_spec(); // .pg_query.PartitionRangeDatum partition_range_datum = 223 [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* partition_range_datum); private: const ::pg_query::PartitionRangeDatum& _internal_partition_range_datum() const; ::pg_query::PartitionRangeDatum* _internal_mutable_partition_range_datum(); public: void unsafe_arena_set_allocated_partition_range_datum( ::pg_query::PartitionRangeDatum* partition_range_datum); ::pg_query::PartitionRangeDatum* unsafe_arena_release_partition_range_datum(); // .pg_query.PartitionCmd partition_cmd = 224 [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* partition_cmd); private: const ::pg_query::PartitionCmd& _internal_partition_cmd() const; ::pg_query::PartitionCmd* _internal_mutable_partition_cmd(); public: void unsafe_arena_set_allocated_partition_cmd( ::pg_query::PartitionCmd* partition_cmd); ::pg_query::PartitionCmd* unsafe_arena_release_partition_cmd(); // .pg_query.VacuumRelation vacuum_relation = 225 [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* vacuum_relation); private: const ::pg_query::VacuumRelation& _internal_vacuum_relation() const; ::pg_query::VacuumRelation* _internal_mutable_vacuum_relation(); public: void unsafe_arena_set_allocated_vacuum_relation( ::pg_query::VacuumRelation* vacuum_relation); ::pg_query::VacuumRelation* unsafe_arena_release_vacuum_relation(); // .pg_query.PublicationObjSpec publication_obj_spec = 226 [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* publication_obj_spec); private: const ::pg_query::PublicationObjSpec& _internal_publication_obj_spec() const; ::pg_query::PublicationObjSpec* _internal_mutable_publication_obj_spec(); public: void unsafe_arena_set_allocated_publication_obj_spec( ::pg_query::PublicationObjSpec* publication_obj_spec); ::pg_query::PublicationObjSpec* unsafe_arena_release_publication_obj_spec(); // .pg_query.PublicationTable publication_table = 227 [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* publication_table); private: const ::pg_query::PublicationTable& _internal_publication_table() const; ::pg_query::PublicationTable* _internal_mutable_publication_table(); public: void unsafe_arena_set_allocated_publication_table( ::pg_query::PublicationTable* publication_table); ::pg_query::PublicationTable* unsafe_arena_release_publication_table(); // .pg_query.InlineCodeBlock inline_code_block = 228 [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* inline_code_block); private: const ::pg_query::InlineCodeBlock& _internal_inline_code_block() const; ::pg_query::InlineCodeBlock* _internal_mutable_inline_code_block(); public: void unsafe_arena_set_allocated_inline_code_block( ::pg_query::InlineCodeBlock* inline_code_block); ::pg_query::InlineCodeBlock* unsafe_arena_release_inline_code_block(); // .pg_query.CallContext call_context = 229 [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* call_context); private: const ::pg_query::CallContext& _internal_call_context() const; ::pg_query::CallContext* _internal_mutable_call_context(); public: void unsafe_arena_set_allocated_call_context( ::pg_query::CallContext* call_context); ::pg_query::CallContext* unsafe_arena_release_call_context(); // .pg_query.Integer integer = 230 [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* integer); private: const ::pg_query::Integer& _internal_integer() const; ::pg_query::Integer* _internal_mutable_integer(); public: void unsafe_arena_set_allocated_integer( ::pg_query::Integer* integer); ::pg_query::Integer* unsafe_arena_release_integer(); // .pg_query.Float float = 231 [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* float_); private: const ::pg_query::Float& _internal_float_() const; ::pg_query::Float* _internal_mutable_float_(); public: void unsafe_arena_set_allocated_float_( ::pg_query::Float* float_); ::pg_query::Float* unsafe_arena_release_float_(); // .pg_query.Boolean boolean = 232 [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* boolean); private: const ::pg_query::Boolean& _internal_boolean() const; ::pg_query::Boolean* _internal_mutable_boolean(); public: void unsafe_arena_set_allocated_boolean( ::pg_query::Boolean* boolean); ::pg_query::Boolean* unsafe_arena_release_boolean(); // .pg_query.String string = 233 [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* string); private: const ::pg_query::String& _internal_string() const; ::pg_query::String* _internal_mutable_string(); public: void unsafe_arena_set_allocated_string( ::pg_query::String* string); ::pg_query::String* unsafe_arena_release_string(); // .pg_query.BitString bit_string = 234 [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* bit_string); private: const ::pg_query::BitString& _internal_bit_string() const; ::pg_query::BitString* _internal_mutable_bit_string(); public: void unsafe_arena_set_allocated_bit_string( ::pg_query::BitString* bit_string); ::pg_query::BitString* unsafe_arena_release_bit_string(); // .pg_query.List list = 235 [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* list); private: const ::pg_query::List& _internal_list() const; ::pg_query::List* _internal_mutable_list(); public: void unsafe_arena_set_allocated_list( ::pg_query::List* list); ::pg_query::List* unsafe_arena_release_list(); // .pg_query.IntList int_list = 236 [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* int_list); private: const ::pg_query::IntList& _internal_int_list() const; ::pg_query::IntList* _internal_mutable_int_list(); public: void unsafe_arena_set_allocated_int_list( ::pg_query::IntList* int_list); ::pg_query::IntList* unsafe_arena_release_int_list(); // .pg_query.OidList oid_list = 237 [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* oid_list); private: const ::pg_query::OidList& _internal_oid_list() const; ::pg_query::OidList* _internal_mutable_oid_list(); public: void unsafe_arena_set_allocated_oid_list( ::pg_query::OidList* oid_list); ::pg_query::OidList* unsafe_arena_release_oid_list(); // .pg_query.A_Const a_const = 238 [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* a_const); private: const ::pg_query::A_Const& _internal_a_const() const; ::pg_query::A_Const* _internal_mutable_a_const(); public: void unsafe_arena_set_allocated_a_const( ::pg_query::A_Const* a_const); ::pg_query::A_Const* unsafe_arena_release_a_const(); 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_var(); void set_has_param(); void set_has_aggref(); void set_has_grouping_func(); void set_has_window_func(); void set_has_subscripting_ref(); void set_has_func_expr(); void set_has_named_arg_expr(); void set_has_op_expr(); void set_has_distinct_expr(); void set_has_null_if_expr(); void set_has_scalar_array_op_expr(); void set_has_bool_expr(); void set_has_sub_link(); void set_has_sub_plan(); void set_has_alternative_sub_plan(); void set_has_field_select(); void set_has_field_store(); void set_has_relabel_type(); void set_has_coerce_via_io(); void set_has_array_coerce_expr(); void set_has_convert_rowtype_expr(); void set_has_collate_expr(); void set_has_case_expr(); void set_has_case_when(); void set_has_case_test_expr(); void set_has_array_expr(); void set_has_row_expr(); void set_has_row_compare_expr(); void set_has_coalesce_expr(); void set_has_min_max_expr(); void set_has_sqlvalue_function(); void set_has_xml_expr(); void set_has_null_test(); void set_has_boolean_test(); void set_has_coerce_to_domain(); void set_has_coerce_to_domain_value(); void set_has_set_to_default(); void set_has_current_of_expr(); void set_has_next_value_expr(); void set_has_inference_elem(); void set_has_target_entry(); void set_has_range_tbl_ref(); void set_has_join_expr(); void set_has_from_expr(); void set_has_on_conflict_expr(); void set_has_into_clause(); void set_has_merge_action(); void set_has_raw_stmt(); void set_has_query(); void set_has_insert_stmt(); void set_has_delete_stmt(); void set_has_update_stmt(); void set_has_merge_stmt(); void set_has_select_stmt(); void set_has_return_stmt(); void set_has_plassign_stmt(); void set_has_alter_table_stmt(); void set_has_alter_table_cmd(); void set_has_alter_domain_stmt(); void set_has_set_operation_stmt(); void set_has_grant_stmt(); void set_has_grant_role_stmt(); void set_has_alter_default_privileges_stmt(); void set_has_close_portal_stmt(); void set_has_cluster_stmt(); void set_has_copy_stmt(); void set_has_create_stmt(); void set_has_define_stmt(); void set_has_drop_stmt(); void set_has_truncate_stmt(); void set_has_comment_stmt(); void set_has_fetch_stmt(); void set_has_index_stmt(); void set_has_create_function_stmt(); void set_has_alter_function_stmt(); void set_has_do_stmt(); void set_has_rename_stmt(); void set_has_rule_stmt(); void set_has_notify_stmt(); void set_has_listen_stmt(); void set_has_unlisten_stmt(); void set_has_transaction_stmt(); void set_has_view_stmt(); void set_has_load_stmt(); void set_has_create_domain_stmt(); void set_has_createdb_stmt(); void set_has_dropdb_stmt(); void set_has_vacuum_stmt(); void set_has_explain_stmt(); void set_has_create_table_as_stmt(); void set_has_create_seq_stmt(); void set_has_alter_seq_stmt(); void set_has_variable_set_stmt(); void set_has_variable_show_stmt(); void set_has_discard_stmt(); void set_has_create_trig_stmt(); void set_has_create_plang_stmt(); void set_has_create_role_stmt(); void set_has_alter_role_stmt(); void set_has_drop_role_stmt(); void set_has_lock_stmt(); void set_has_constraints_set_stmt(); void set_has_reindex_stmt(); void set_has_check_point_stmt(); void set_has_create_schema_stmt(); void set_has_alter_database_stmt(); void set_has_alter_database_refresh_coll_stmt(); void set_has_alter_database_set_stmt(); void set_has_alter_role_set_stmt(); void set_has_create_conversion_stmt(); void set_has_create_cast_stmt(); void set_has_create_op_class_stmt(); void set_has_create_op_family_stmt(); void set_has_alter_op_family_stmt(); void set_has_prepare_stmt(); void set_has_execute_stmt(); void set_has_deallocate_stmt(); void set_has_declare_cursor_stmt(); void set_has_create_table_space_stmt(); void set_has_drop_table_space_stmt(); void set_has_alter_object_depends_stmt(); void set_has_alter_object_schema_stmt(); void set_has_alter_owner_stmt(); void set_has_alter_operator_stmt(); void set_has_alter_type_stmt(); void set_has_drop_owned_stmt(); void set_has_reassign_owned_stmt(); void set_has_composite_type_stmt(); void set_has_create_enum_stmt(); void set_has_create_range_stmt(); void set_has_alter_enum_stmt(); void set_has_alter_tsdictionary_stmt(); void set_has_alter_tsconfiguration_stmt(); void set_has_create_fdw_stmt(); void set_has_alter_fdw_stmt(); void set_has_create_foreign_server_stmt(); void set_has_alter_foreign_server_stmt(); void set_has_create_user_mapping_stmt(); void set_has_alter_user_mapping_stmt(); void set_has_drop_user_mapping_stmt(); void set_has_alter_table_space_options_stmt(); void set_has_alter_table_move_all_stmt(); void set_has_sec_label_stmt(); void set_has_create_foreign_table_stmt(); void set_has_import_foreign_schema_stmt(); void set_has_create_extension_stmt(); void set_has_alter_extension_stmt(); void set_has_alter_extension_contents_stmt(); void set_has_create_event_trig_stmt(); void set_has_alter_event_trig_stmt(); void set_has_refresh_mat_view_stmt(); void set_has_replica_identity_stmt(); void set_has_alter_system_stmt(); void set_has_create_policy_stmt(); void set_has_alter_policy_stmt(); void set_has_create_transform_stmt(); void set_has_create_am_stmt(); void set_has_create_publication_stmt(); void set_has_alter_publication_stmt(); void set_has_create_subscription_stmt(); void set_has_alter_subscription_stmt(); void set_has_drop_subscription_stmt(); void set_has_create_stats_stmt(); void set_has_alter_collation_stmt(); void set_has_call_stmt(); void set_has_alter_stats_stmt(); void set_has_a_expr(); void set_has_column_ref(); void set_has_param_ref(); void set_has_func_call(); void set_has_a_star(); void set_has_a_indices(); void set_has_a_indirection(); void set_has_a_array_expr(); void set_has_res_target(); void set_has_multi_assign_ref(); void set_has_type_cast(); void set_has_collate_clause(); void set_has_sort_by(); void set_has_window_def(); void set_has_range_subselect(); void set_has_range_function(); void set_has_range_table_sample(); void set_has_range_table_func(); void set_has_range_table_func_col(); void set_has_type_name(); void set_has_column_def(); void set_has_index_elem(); void set_has_stats_elem(); void set_has_constraint(); void set_has_def_elem(); void set_has_range_tbl_entry(); void set_has_range_tbl_function(); void set_has_table_sample_clause(); void set_has_with_check_option(); void set_has_sort_group_clause(); void set_has_grouping_set(); void set_has_window_clause(); void set_has_object_with_args(); void set_has_access_priv(); void set_has_create_op_class_item(); void set_has_table_like_clause(); void set_has_function_parameter(); void set_has_locking_clause(); void set_has_row_mark_clause(); void set_has_xml_serialize(); void set_has_with_clause(); void set_has_infer_clause(); void set_has_on_conflict_clause(); void set_has_ctesearch_clause(); void set_has_ctecycle_clause(); void set_has_common_table_expr(); void set_has_merge_when_clause(); void set_has_role_spec(); void set_has_trigger_transition(); void set_has_partition_elem(); void set_has_partition_spec(); void set_has_partition_bound_spec(); void set_has_partition_range_datum(); void set_has_partition_cmd(); void set_has_vacuum_relation(); void set_has_publication_obj_spec(); void set_has_publication_table(); void set_has_inline_code_block(); void set_has_call_context(); 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(); template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { union NodeUnion { constexpr NodeUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; ::pg_query::Alias* alias_; ::pg_query::RangeVar* range_var_; ::pg_query::TableFunc* table_func_; ::pg_query::Var* var_; ::pg_query::Param* param_; ::pg_query::Aggref* aggref_; ::pg_query::GroupingFunc* grouping_func_; ::pg_query::WindowFunc* window_func_; ::pg_query::SubscriptingRef* subscripting_ref_; ::pg_query::FuncExpr* func_expr_; ::pg_query::NamedArgExpr* named_arg_expr_; ::pg_query::OpExpr* op_expr_; ::pg_query::DistinctExpr* distinct_expr_; ::pg_query::NullIfExpr* null_if_expr_; ::pg_query::ScalarArrayOpExpr* scalar_array_op_expr_; ::pg_query::BoolExpr* bool_expr_; ::pg_query::SubLink* sub_link_; ::pg_query::SubPlan* sub_plan_; ::pg_query::AlternativeSubPlan* alternative_sub_plan_; ::pg_query::FieldSelect* field_select_; ::pg_query::FieldStore* field_store_; ::pg_query::RelabelType* relabel_type_; ::pg_query::CoerceViaIO* coerce_via_io_; ::pg_query::ArrayCoerceExpr* array_coerce_expr_; ::pg_query::ConvertRowtypeExpr* convert_rowtype_expr_; ::pg_query::CollateExpr* collate_expr_; ::pg_query::CaseExpr* case_expr_; ::pg_query::CaseWhen* case_when_; ::pg_query::CaseTestExpr* case_test_expr_; ::pg_query::ArrayExpr* array_expr_; ::pg_query::RowExpr* row_expr_; ::pg_query::RowCompareExpr* row_compare_expr_; ::pg_query::CoalesceExpr* coalesce_expr_; ::pg_query::MinMaxExpr* min_max_expr_; ::pg_query::SQLValueFunction* sqlvalue_function_; ::pg_query::XmlExpr* xml_expr_; ::pg_query::NullTest* null_test_; ::pg_query::BooleanTest* boolean_test_; ::pg_query::CoerceToDomain* coerce_to_domain_; ::pg_query::CoerceToDomainValue* coerce_to_domain_value_; ::pg_query::SetToDefault* set_to_default_; ::pg_query::CurrentOfExpr* current_of_expr_; ::pg_query::NextValueExpr* next_value_expr_; ::pg_query::InferenceElem* inference_elem_; ::pg_query::TargetEntry* target_entry_; ::pg_query::RangeTblRef* range_tbl_ref_; ::pg_query::JoinExpr* join_expr_; ::pg_query::FromExpr* from_expr_; ::pg_query::OnConflictExpr* on_conflict_expr_; ::pg_query::IntoClause* into_clause_; ::pg_query::MergeAction* merge_action_; ::pg_query::RawStmt* raw_stmt_; ::pg_query::Query* query_; ::pg_query::InsertStmt* insert_stmt_; ::pg_query::DeleteStmt* delete_stmt_; ::pg_query::UpdateStmt* update_stmt_; ::pg_query::MergeStmt* merge_stmt_; ::pg_query::SelectStmt* select_stmt_; ::pg_query::ReturnStmt* return_stmt_; ::pg_query::PLAssignStmt* plassign_stmt_; ::pg_query::AlterTableStmt* alter_table_stmt_; ::pg_query::AlterTableCmd* alter_table_cmd_; ::pg_query::AlterDomainStmt* alter_domain_stmt_; ::pg_query::SetOperationStmt* set_operation_stmt_; ::pg_query::GrantStmt* grant_stmt_; ::pg_query::GrantRoleStmt* grant_role_stmt_; ::pg_query::AlterDefaultPrivilegesStmt* alter_default_privileges_stmt_; ::pg_query::ClosePortalStmt* close_portal_stmt_; ::pg_query::ClusterStmt* cluster_stmt_; ::pg_query::CopyStmt* copy_stmt_; ::pg_query::CreateStmt* create_stmt_; ::pg_query::DefineStmt* define_stmt_; ::pg_query::DropStmt* drop_stmt_; ::pg_query::TruncateStmt* truncate_stmt_; ::pg_query::CommentStmt* comment_stmt_; ::pg_query::FetchStmt* fetch_stmt_; ::pg_query::IndexStmt* index_stmt_; ::pg_query::CreateFunctionStmt* create_function_stmt_; ::pg_query::AlterFunctionStmt* alter_function_stmt_; ::pg_query::DoStmt* do_stmt_; ::pg_query::RenameStmt* rename_stmt_; ::pg_query::RuleStmt* rule_stmt_; ::pg_query::NotifyStmt* notify_stmt_; ::pg_query::ListenStmt* listen_stmt_; ::pg_query::UnlistenStmt* unlisten_stmt_; ::pg_query::TransactionStmt* transaction_stmt_; ::pg_query::ViewStmt* view_stmt_; ::pg_query::LoadStmt* load_stmt_; ::pg_query::CreateDomainStmt* create_domain_stmt_; ::pg_query::CreatedbStmt* createdb_stmt_; ::pg_query::DropdbStmt* dropdb_stmt_; ::pg_query::VacuumStmt* vacuum_stmt_; ::pg_query::ExplainStmt* explain_stmt_; ::pg_query::CreateTableAsStmt* create_table_as_stmt_; ::pg_query::CreateSeqStmt* create_seq_stmt_; ::pg_query::AlterSeqStmt* alter_seq_stmt_; ::pg_query::VariableSetStmt* variable_set_stmt_; ::pg_query::VariableShowStmt* variable_show_stmt_; ::pg_query::DiscardStmt* discard_stmt_; ::pg_query::CreateTrigStmt* create_trig_stmt_; ::pg_query::CreatePLangStmt* create_plang_stmt_; ::pg_query::CreateRoleStmt* create_role_stmt_; ::pg_query::AlterRoleStmt* alter_role_stmt_; ::pg_query::DropRoleStmt* drop_role_stmt_; ::pg_query::LockStmt* lock_stmt_; ::pg_query::ConstraintsSetStmt* constraints_set_stmt_; ::pg_query::ReindexStmt* reindex_stmt_; ::pg_query::CheckPointStmt* check_point_stmt_; ::pg_query::CreateSchemaStmt* create_schema_stmt_; ::pg_query::AlterDatabaseStmt* alter_database_stmt_; ::pg_query::AlterDatabaseRefreshCollStmt* alter_database_refresh_coll_stmt_; ::pg_query::AlterDatabaseSetStmt* alter_database_set_stmt_; ::pg_query::AlterRoleSetStmt* alter_role_set_stmt_; ::pg_query::CreateConversionStmt* create_conversion_stmt_; ::pg_query::CreateCastStmt* create_cast_stmt_; ::pg_query::CreateOpClassStmt* create_op_class_stmt_; ::pg_query::CreateOpFamilyStmt* create_op_family_stmt_; ::pg_query::AlterOpFamilyStmt* alter_op_family_stmt_; ::pg_query::PrepareStmt* prepare_stmt_; ::pg_query::ExecuteStmt* execute_stmt_; ::pg_query::DeallocateStmt* deallocate_stmt_; ::pg_query::DeclareCursorStmt* declare_cursor_stmt_; ::pg_query::CreateTableSpaceStmt* create_table_space_stmt_; ::pg_query::DropTableSpaceStmt* drop_table_space_stmt_; ::pg_query::AlterObjectDependsStmt* alter_object_depends_stmt_; ::pg_query::AlterObjectSchemaStmt* alter_object_schema_stmt_; ::pg_query::AlterOwnerStmt* alter_owner_stmt_; ::pg_query::AlterOperatorStmt* alter_operator_stmt_; ::pg_query::AlterTypeStmt* alter_type_stmt_; ::pg_query::DropOwnedStmt* drop_owned_stmt_; ::pg_query::ReassignOwnedStmt* reassign_owned_stmt_; ::pg_query::CompositeTypeStmt* composite_type_stmt_; ::pg_query::CreateEnumStmt* create_enum_stmt_; ::pg_query::CreateRangeStmt* create_range_stmt_; ::pg_query::AlterEnumStmt* alter_enum_stmt_; ::pg_query::AlterTSDictionaryStmt* alter_tsdictionary_stmt_; ::pg_query::AlterTSConfigurationStmt* alter_tsconfiguration_stmt_; ::pg_query::CreateFdwStmt* create_fdw_stmt_; ::pg_query::AlterFdwStmt* alter_fdw_stmt_; ::pg_query::CreateForeignServerStmt* create_foreign_server_stmt_; ::pg_query::AlterForeignServerStmt* alter_foreign_server_stmt_; ::pg_query::CreateUserMappingStmt* create_user_mapping_stmt_; ::pg_query::AlterUserMappingStmt* alter_user_mapping_stmt_; ::pg_query::DropUserMappingStmt* drop_user_mapping_stmt_; ::pg_query::AlterTableSpaceOptionsStmt* alter_table_space_options_stmt_; ::pg_query::AlterTableMoveAllStmt* alter_table_move_all_stmt_; ::pg_query::SecLabelStmt* sec_label_stmt_; ::pg_query::CreateForeignTableStmt* create_foreign_table_stmt_; ::pg_query::ImportForeignSchemaStmt* import_foreign_schema_stmt_; ::pg_query::CreateExtensionStmt* create_extension_stmt_; ::pg_query::AlterExtensionStmt* alter_extension_stmt_; ::pg_query::AlterExtensionContentsStmt* alter_extension_contents_stmt_; ::pg_query::CreateEventTrigStmt* create_event_trig_stmt_; ::pg_query::AlterEventTrigStmt* alter_event_trig_stmt_; ::pg_query::RefreshMatViewStmt* refresh_mat_view_stmt_; ::pg_query::ReplicaIdentityStmt* replica_identity_stmt_; ::pg_query::AlterSystemStmt* alter_system_stmt_; ::pg_query::CreatePolicyStmt* create_policy_stmt_; ::pg_query::AlterPolicyStmt* alter_policy_stmt_; ::pg_query::CreateTransformStmt* create_transform_stmt_; ::pg_query::CreateAmStmt* create_am_stmt_; ::pg_query::CreatePublicationStmt* create_publication_stmt_; ::pg_query::AlterPublicationStmt* alter_publication_stmt_; ::pg_query::CreateSubscriptionStmt* create_subscription_stmt_; ::pg_query::AlterSubscriptionStmt* alter_subscription_stmt_; ::pg_query::DropSubscriptionStmt* drop_subscription_stmt_; ::pg_query::CreateStatsStmt* create_stats_stmt_; ::pg_query::AlterCollationStmt* alter_collation_stmt_; ::pg_query::CallStmt* call_stmt_; ::pg_query::AlterStatsStmt* alter_stats_stmt_; ::pg_query::A_Expr* a_expr_; ::pg_query::ColumnRef* column_ref_; ::pg_query::ParamRef* param_ref_; ::pg_query::FuncCall* func_call_; ::pg_query::A_Star* a_star_; ::pg_query::A_Indices* a_indices_; ::pg_query::A_Indirection* a_indirection_; ::pg_query::A_ArrayExpr* a_array_expr_; ::pg_query::ResTarget* res_target_; ::pg_query::MultiAssignRef* multi_assign_ref_; ::pg_query::TypeCast* type_cast_; ::pg_query::CollateClause* collate_clause_; ::pg_query::SortBy* sort_by_; ::pg_query::WindowDef* window_def_; ::pg_query::RangeSubselect* range_subselect_; ::pg_query::RangeFunction* range_function_; ::pg_query::RangeTableSample* range_table_sample_; ::pg_query::RangeTableFunc* range_table_func_; ::pg_query::RangeTableFuncCol* range_table_func_col_; ::pg_query::TypeName* type_name_; ::pg_query::ColumnDef* column_def_; ::pg_query::IndexElem* index_elem_; ::pg_query::StatsElem* stats_elem_; ::pg_query::Constraint* constraint_; ::pg_query::DefElem* def_elem_; ::pg_query::RangeTblEntry* range_tbl_entry_; ::pg_query::RangeTblFunction* range_tbl_function_; ::pg_query::TableSampleClause* table_sample_clause_; ::pg_query::WithCheckOption* with_check_option_; ::pg_query::SortGroupClause* sort_group_clause_; ::pg_query::GroupingSet* grouping_set_; ::pg_query::WindowClause* window_clause_; ::pg_query::ObjectWithArgs* object_with_args_; ::pg_query::AccessPriv* access_priv_; ::pg_query::CreateOpClassItem* create_op_class_item_; ::pg_query::TableLikeClause* table_like_clause_; ::pg_query::FunctionParameter* function_parameter_; ::pg_query::LockingClause* locking_clause_; ::pg_query::RowMarkClause* row_mark_clause_; ::pg_query::XmlSerialize* xml_serialize_; ::pg_query::WithClause* with_clause_; ::pg_query::InferClause* infer_clause_; ::pg_query::OnConflictClause* on_conflict_clause_; ::pg_query::CTESearchClause* ctesearch_clause_; ::pg_query::CTECycleClause* ctecycle_clause_; ::pg_query::CommonTableExpr* common_table_expr_; ::pg_query::MergeWhenClause* merge_when_clause_; ::pg_query::RoleSpec* role_spec_; ::pg_query::TriggerTransition* trigger_transition_; ::pg_query::PartitionElem* partition_elem_; ::pg_query::PartitionSpec* partition_spec_; ::pg_query::PartitionBoundSpec* partition_bound_spec_; ::pg_query::PartitionRangeDatum* partition_range_datum_; ::pg_query::PartitionCmd* partition_cmd_; ::pg_query::VacuumRelation* vacuum_relation_; ::pg_query::PublicationObjSpec* publication_obj_spec_; ::pg_query::PublicationTable* publication_table_; ::pg_query::InlineCodeBlock* inline_code_block_; ::pg_query::CallContext* call_context_; ::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 ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; uint32_t _oneof_case_[1]; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class Integer final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.Integer) */ { public: inline Integer() : Integer(nullptr) {} ~Integer() override; explicit PROTOBUF_CONSTEXPR Integer(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); Integer(const Integer& from); Integer(Integer&& from) noexcept : Integer() { *this = ::std::move(from); } inline Integer& operator=(const Integer& from) { CopyFrom(from); return *this; } inline Integer& operator=(Integer&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(Integer* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- Integer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Integer& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const Integer& from) { Integer::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Integer* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.Integer"; } protected: explicit Integer(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { int32_t ival_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class Float final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.Float) */ { public: inline Float() : Float(nullptr) {} ~Float() override; explicit PROTOBUF_CONSTEXPR Float(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); Float(const Float& from); Float(Float&& from) noexcept : Float() { *this = ::std::move(from); } inline Float& operator=(const Float& from) { CopyFrom(from); return *this; } inline Float& operator=(Float&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(Float* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- Float* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Float& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const Float& from) { Float::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Float* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.Float"; } protected: explicit Float(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kFvalFieldNumber = 1, }; // string fval = 1; void clear_fval(); const std::string& fval() const; template void set_fval(ArgT0&& arg0, ArgT... args); std::string* mutable_fval(); PROTOBUF_NODISCARD std::string* release_fval(); void set_allocated_fval(std::string* fval); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fval_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class Boolean final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.Boolean) */ { public: inline Boolean() : Boolean(nullptr) {} ~Boolean() override; explicit PROTOBUF_CONSTEXPR Boolean(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); Boolean(const Boolean& 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 (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(Boolean* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- Boolean* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Boolean& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const Boolean& from) { Boolean::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Boolean* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.Boolean"; } protected: explicit Boolean(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { bool boolval_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class String final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.String) */ { public: inline String() : String(nullptr) {} ~String() override; explicit PROTOBUF_CONSTEXPR String(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); String(const String& from); String(String&& from) noexcept : String() { *this = ::std::move(from); } inline String& operator=(const String& from) { CopyFrom(from); return *this; } inline String& operator=(String&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(String* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- String* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const String& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const String& from) { String::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(String* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.String"; } protected: explicit String(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kSvalFieldNumber = 1, }; // string sval = 1; void clear_sval(); const std::string& sval() const; template void set_sval(ArgT0&& arg0, ArgT... args); std::string* mutable_sval(); PROTOBUF_NODISCARD std::string* release_sval(); void set_allocated_sval(std::string* sval); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sval_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class BitString final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.BitString) */ { public: inline BitString() : BitString(nullptr) {} ~BitString() override; explicit PROTOBUF_CONSTEXPR BitString(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); BitString(const BitString& from); BitString(BitString&& from) noexcept : BitString() { *this = ::std::move(from); } inline BitString& operator=(const BitString& from) { CopyFrom(from); return *this; } inline BitString& operator=(BitString&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(BitString* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- BitString* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const BitString& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const BitString& from) { BitString::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(BitString* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.BitString"; } protected: explicit BitString(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kBsvalFieldNumber = 1, }; // string bsval = 1; void clear_bsval(); const std::string& bsval() const; template void set_bsval(ArgT0&& arg0, ArgT... args); std::string* mutable_bsval(); PROTOBUF_NODISCARD std::string* release_bsval(); void set_allocated_bsval(std::string* bsval); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bsval_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class List final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.List) */ { public: inline List() : List(nullptr) {} ~List() override; explicit PROTOBUF_CONSTEXPR List(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); List(const List& from); List(List&& from) noexcept : List() { *this = ::std::move(from); } inline List& operator=(const List& from) { CopyFrom(from); return *this; } inline List& operator=(List&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(List* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- List* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const List& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const List& from) { List::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(List* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.List"; } protected: explicit List(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_items(); private: const ::pg_query::Node& _internal_items(int index) const; ::pg_query::Node* _internal_add_items(); public: const ::pg_query::Node& items(int index) const; ::pg_query::Node* add_items(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& items() const; // @@protoc_insertion_point(class_scope:pg_query.List) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > items_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class OidList final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.OidList) */ { public: inline OidList() : OidList(nullptr) {} ~OidList() override; explicit PROTOBUF_CONSTEXPR OidList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); OidList(const OidList& from); OidList(OidList&& from) noexcept : OidList() { *this = ::std::move(from); } inline OidList& operator=(const OidList& from) { CopyFrom(from); return *this; } inline OidList& operator=(OidList&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(OidList* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- OidList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const OidList& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const OidList& from) { OidList::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(OidList* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.OidList"; } protected: explicit OidList(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_items(); private: const ::pg_query::Node& _internal_items(int index) const; ::pg_query::Node* _internal_add_items(); public: const ::pg_query::Node& items(int index) const; ::pg_query::Node* add_items(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& items() const; // @@protoc_insertion_point(class_scope:pg_query.OidList) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > items_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class IntList final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.IntList) */ { public: inline IntList() : IntList(nullptr) {} ~IntList() override; explicit PROTOBUF_CONSTEXPR IntList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); IntList(const IntList& from); IntList(IntList&& from) noexcept : IntList() { *this = ::std::move(from); } inline IntList& operator=(const IntList& from) { CopyFrom(from); return *this; } inline IntList& operator=(IntList&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(IntList* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- IntList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const IntList& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const IntList& from) { IntList::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(IntList* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.IntList"; } protected: explicit IntList(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_items(); private: const ::pg_query::Node& _internal_items(int index) const; ::pg_query::Node* _internal_add_items(); public: const ::pg_query::Node& items(int index) const; ::pg_query::Node* add_items(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& items() const; // @@protoc_insertion_point(class_scope:pg_query.IntList) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > items_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class A_Const final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.A_Const) */ { public: inline A_Const() : A_Const(nullptr) {} ~A_Const() override; explicit PROTOBUF_CONSTEXPR A_Const(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); A_Const(const A_Const& from); A_Const(A_Const&& from) noexcept : A_Const() { *this = ::std::move(from); } inline A_Const& operator=(const A_Const& from) { CopyFrom(from); return *this; } inline A_Const& operator=(A_Const&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(A_Const* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- A_Const* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const A_Const& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const A_Const& from) { A_Const::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(A_Const* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.A_Const"; } protected: explicit A_Const(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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* ival); private: const ::pg_query::Integer& _internal_ival() const; ::pg_query::Integer* _internal_mutable_ival(); public: void unsafe_arena_set_allocated_ival( ::pg_query::Integer* ival); ::pg_query::Integer* unsafe_arena_release_ival(); // .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* fval); private: const ::pg_query::Float& _internal_fval() const; ::pg_query::Float* _internal_mutable_fval(); public: void unsafe_arena_set_allocated_fval( ::pg_query::Float* fval); ::pg_query::Float* unsafe_arena_release_fval(); // .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* boolval); private: const ::pg_query::Boolean& _internal_boolval() const; ::pg_query::Boolean* _internal_mutable_boolval(); public: void unsafe_arena_set_allocated_boolval( ::pg_query::Boolean* boolval); ::pg_query::Boolean* unsafe_arena_release_boolval(); // .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* sval); private: const ::pg_query::String& _internal_sval() const; ::pg_query::String* _internal_mutable_sval(); public: void unsafe_arena_set_allocated_sval( ::pg_query::String* sval); ::pg_query::String* unsafe_arena_release_sval(); // .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* bsval); private: const ::pg_query::BitString& _internal_bsval() const; ::pg_query::BitString* _internal_mutable_bsval(); public: void unsafe_arena_set_allocated_bsval( ::pg_query::BitString* bsval); ::pg_query::BitString* unsafe_arena_release_bsval(); 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(); template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { bool isnull_; int32_t location_; union ValUnion { constexpr ValUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::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 ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; uint32_t _oneof_case_[1]; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class Alias final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.Alias) */ { public: inline Alias() : Alias(nullptr) {} ~Alias() override; explicit PROTOBUF_CONSTEXPR Alias(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); Alias(const Alias& from); Alias(Alias&& from) noexcept : Alias() { *this = ::std::move(from); } inline Alias& operator=(const Alias& from) { CopyFrom(from); return *this; } inline Alias& operator=(Alias&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(Alias* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- Alias* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Alias& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const Alias& from) { Alias::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Alias* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.Alias"; } protected: explicit Alias(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_colnames(); private: const ::pg_query::Node& _internal_colnames(int index) const; ::pg_query::Node* _internal_add_colnames(); public: const ::pg_query::Node& colnames(int index) const; ::pg_query::Node* add_colnames(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& colnames() const; // string aliasname = 1 [json_name = "aliasname"]; void clear_aliasname(); const std::string& aliasname() const; template void set_aliasname(ArgT0&& arg0, ArgT... args); std::string* mutable_aliasname(); PROTOBUF_NODISCARD std::string* release_aliasname(); void set_allocated_aliasname(std::string* aliasname); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > colnames_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr aliasname_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class RangeVar final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RangeVar) */ { public: inline RangeVar() : RangeVar(nullptr) {} ~RangeVar() override; explicit PROTOBUF_CONSTEXPR RangeVar(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); RangeVar(const RangeVar& from); RangeVar(RangeVar&& from) noexcept : RangeVar() { *this = ::std::move(from); } inline RangeVar& operator=(const RangeVar& from) { CopyFrom(from); return *this; } inline RangeVar& operator=(RangeVar&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(RangeVar* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- RangeVar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const RangeVar& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const RangeVar& from) { RangeVar::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(RangeVar* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.RangeVar"; } protected: explicit RangeVar(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_catalogname(ArgT0&& arg0, ArgT... args); std::string* mutable_catalogname(); PROTOBUF_NODISCARD std::string* release_catalogname(); void set_allocated_catalogname(std::string* catalogname); 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 void set_schemaname(ArgT0&& arg0, ArgT... args); std::string* mutable_schemaname(); PROTOBUF_NODISCARD std::string* release_schemaname(); void set_allocated_schemaname(std::string* schemaname); 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 void set_relname(ArgT0&& arg0, ArgT... args); std::string* mutable_relname(); PROTOBUF_NODISCARD std::string* release_relname(); void set_allocated_relname(std::string* relname); 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 void set_relpersistence(ArgT0&& arg0, ArgT... args); std::string* mutable_relpersistence(); PROTOBUF_NODISCARD std::string* release_relpersistence(); void set_allocated_relpersistence(std::string* relpersistence); 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; 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* alias); private: const ::pg_query::Alias& _internal_alias() const; ::pg_query::Alias* _internal_mutable_alias(); public: void unsafe_arena_set_allocated_alias( ::pg_query::Alias* alias); ::pg_query::Alias* unsafe_arena_release_alias(); // bool inh = 4 [json_name = "inh"]; void clear_inh(); bool inh() const; void set_inh(bool value); private: bool _internal_inh() const; void _internal_set_inh(bool value); public: // int32 location = 7 [json_name = "location"]; void clear_location(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr catalogname_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr schemaname_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr relname_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr relpersistence_; ::pg_query::Alias* alias_; bool inh_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class TableFunc final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.TableFunc) */ { public: inline TableFunc() : TableFunc(nullptr) {} ~TableFunc() override; explicit PROTOBUF_CONSTEXPR TableFunc(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); TableFunc(const TableFunc& from); TableFunc(TableFunc&& from) noexcept : TableFunc() { *this = ::std::move(from); } inline TableFunc& operator=(const TableFunc& from) { CopyFrom(from); return *this; } inline TableFunc& operator=(TableFunc&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(TableFunc* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- TableFunc* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const TableFunc& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const TableFunc& from) { TableFunc::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(TableFunc* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.TableFunc"; } protected: explicit TableFunc(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_ns_uris(); private: const ::pg_query::Node& _internal_ns_uris(int index) const; ::pg_query::Node* _internal_add_ns_uris(); public: const ::pg_query::Node& ns_uris(int index) const; ::pg_query::Node* add_ns_uris(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& ns_uris() const; // repeated .pg_query.Node ns_names = 2 [json_name = "ns_names"]; int ns_names_size() const; private: int _internal_ns_names_size() const; public: void clear_ns_names(); ::pg_query::Node* mutable_ns_names(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_ns_names(); private: const ::pg_query::Node& _internal_ns_names(int index) const; ::pg_query::Node* _internal_add_ns_names(); public: const ::pg_query::Node& ns_names(int index) const; ::pg_query::Node* add_ns_names(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& ns_names() const; // repeated .pg_query.Node colnames = 5 [json_name = "colnames"]; int colnames_size() const; private: int _internal_colnames_size() const; public: void clear_colnames(); ::pg_query::Node* mutable_colnames(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_colnames(); private: const ::pg_query::Node& _internal_colnames(int index) const; ::pg_query::Node* _internal_add_colnames(); public: const ::pg_query::Node& colnames(int index) const; ::pg_query::Node* add_colnames(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& colnames() const; // repeated .pg_query.Node coltypes = 6 [json_name = "coltypes"]; int coltypes_size() const; private: int _internal_coltypes_size() const; public: void clear_coltypes(); ::pg_query::Node* mutable_coltypes(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_coltypes(); private: const ::pg_query::Node& _internal_coltypes(int index) const; ::pg_query::Node* _internal_add_coltypes(); public: const ::pg_query::Node& coltypes(int index) const; ::pg_query::Node* add_coltypes(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& coltypes() const; // repeated .pg_query.Node coltypmods = 7 [json_name = "coltypmods"]; int coltypmods_size() const; private: int _internal_coltypmods_size() const; public: void clear_coltypmods(); ::pg_query::Node* mutable_coltypmods(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_coltypmods(); private: const ::pg_query::Node& _internal_coltypmods(int index) const; ::pg_query::Node* _internal_add_coltypmods(); public: const ::pg_query::Node& coltypmods(int index) const; ::pg_query::Node* add_coltypmods(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& coltypmods() const; // repeated .pg_query.Node colcollations = 8 [json_name = "colcollations"]; int colcollations_size() const; private: int _internal_colcollations_size() const; public: void clear_colcollations(); ::pg_query::Node* mutable_colcollations(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_colcollations(); private: const ::pg_query::Node& _internal_colcollations(int index) const; ::pg_query::Node* _internal_add_colcollations(); public: const ::pg_query::Node& colcollations(int index) const; ::pg_query::Node* add_colcollations(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& colcollations() const; // repeated .pg_query.Node colexprs = 9 [json_name = "colexprs"]; int colexprs_size() const; private: int _internal_colexprs_size() const; public: void clear_colexprs(); ::pg_query::Node* mutable_colexprs(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_colexprs(); private: const ::pg_query::Node& _internal_colexprs(int index) const; ::pg_query::Node* _internal_add_colexprs(); public: const ::pg_query::Node& colexprs(int index) const; ::pg_query::Node* add_colexprs(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& colexprs() const; // repeated .pg_query.Node coldefexprs = 10 [json_name = "coldefexprs"]; int coldefexprs_size() const; private: int _internal_coldefexprs_size() const; public: void clear_coldefexprs(); ::pg_query::Node* mutable_coldefexprs(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_coldefexprs(); private: const ::pg_query::Node& _internal_coldefexprs(int index) const; ::pg_query::Node* _internal_add_coldefexprs(); public: const ::pg_query::Node& coldefexprs(int index) const; ::pg_query::Node* add_coldefexprs(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& coldefexprs() const; // repeated uint64 notnulls = 11 [json_name = "notnulls"]; int notnulls_size() const; private: int _internal_notnulls_size() const; public: void clear_notnulls(); private: uint64_t _internal_notnulls(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >& _internal_notnulls() const; void _internal_add_notnulls(uint64_t value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >* _internal_mutable_notnulls(); public: uint64_t notnulls(int index) const; void set_notnulls(int index, uint64_t value); void add_notnulls(uint64_t value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >& notnulls() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >* mutable_notnulls(); // .pg_query.Node docexpr = 3 [json_name = "docexpr"]; bool has_docexpr() const; private: bool _internal_has_docexpr() const; public: void clear_docexpr(); const ::pg_query::Node& docexpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_docexpr(); ::pg_query::Node* mutable_docexpr(); void set_allocated_docexpr(::pg_query::Node* docexpr); private: const ::pg_query::Node& _internal_docexpr() const; ::pg_query::Node* _internal_mutable_docexpr(); public: void unsafe_arena_set_allocated_docexpr( ::pg_query::Node* docexpr); ::pg_query::Node* unsafe_arena_release_docexpr(); // .pg_query.Node rowexpr = 4 [json_name = "rowexpr"]; bool has_rowexpr() const; private: bool _internal_has_rowexpr() const; public: void clear_rowexpr(); const ::pg_query::Node& rowexpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_rowexpr(); ::pg_query::Node* mutable_rowexpr(); void set_allocated_rowexpr(::pg_query::Node* rowexpr); private: const ::pg_query::Node& _internal_rowexpr() const; ::pg_query::Node* _internal_mutable_rowexpr(); public: void unsafe_arena_set_allocated_rowexpr( ::pg_query::Node* rowexpr); ::pg_query::Node* unsafe_arena_release_rowexpr(); // int32 ordinalitycol = 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > ns_uris_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > ns_names_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > colnames_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > coltypes_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > coltypmods_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > colcollations_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > colexprs_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > coldefexprs_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > notnulls_; mutable std::atomic _notnulls_cached_byte_size_; ::pg_query::Node* docexpr_; ::pg_query::Node* rowexpr_; int32_t ordinalitycol_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class Var final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.Var) */ { public: inline Var() : Var(nullptr) {} ~Var() override; explicit PROTOBUF_CONSTEXPR Var(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); Var(const Var& from); Var(Var&& from) noexcept : Var() { *this = ::std::move(from); } inline Var& operator=(const Var& from) { CopyFrom(from); return *this; } inline Var& operator=(Var&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_Var_default_instance_); } static constexpr int kIndexInFileMessages = 15; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(Var* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- Var* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Var& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const Var& from) { Var::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Var* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.Var"; } protected: explicit Var(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kXprFieldNumber = 1, kVarnoFieldNumber = 2, kVarattnoFieldNumber = 3, kVartypeFieldNumber = 4, kVartypmodFieldNumber = 5, kVarcollidFieldNumber = 6, kVarlevelsupFieldNumber = 7, kVarnosynFieldNumber = 8, kVarattnosynFieldNumber = 9, kLocationFieldNumber = 10, }; // .pg_query.Node xpr = 1 [json_name = "xpr"]; bool has_xpr() const; private: bool _internal_has_xpr() const; public: void clear_xpr(); const ::pg_query::Node& xpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_xpr(); ::pg_query::Node* mutable_xpr(); void set_allocated_xpr(::pg_query::Node* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // 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 = 7 [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: // uint32 varnosyn = 8 [json_name = "varnosyn"]; void clear_varnosyn(); uint32_t varnosyn() const; void set_varnosyn(uint32_t value); private: uint32_t _internal_varnosyn() const; void _internal_set_varnosyn(uint32_t value); public: // int32 varattnosyn = 9 [json_name = "varattnosyn"]; void clear_varattnosyn(); int32_t varattnosyn() const; void set_varattnosyn(int32_t value); private: int32_t _internal_varattnosyn() const; void _internal_set_varattnosyn(int32_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.Var) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::Node* xpr_; int32_t varno_; int32_t varattno_; uint32_t vartype_; int32_t vartypmod_; uint32_t varcollid_; uint32_t varlevelsup_; uint32_t varnosyn_; int32_t varattnosyn_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class Param final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.Param) */ { public: inline Param() : Param(nullptr) {} ~Param() override; explicit PROTOBUF_CONSTEXPR Param(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); Param(const Param& from); Param(Param&& from) noexcept : Param() { *this = ::std::move(from); } inline Param& operator=(const Param& from) { CopyFrom(from); return *this; } inline Param& operator=(Param&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_Param_default_instance_); } static constexpr int kIndexInFileMessages = 16; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(Param* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- Param* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Param& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const Param& from) { Param::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Param* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.Param"; } protected: explicit Param(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_xpr() const; public: 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* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // .pg_query.ParamKind paramkind = 2 [json_name = "paramkind"]; void clear_paramkind(); ::pg_query::ParamKind paramkind() const; void set_paramkind(::pg_query::ParamKind value); private: ::pg_query::ParamKind _internal_paramkind() const; void _internal_set_paramkind(::pg_query::ParamKind value); public: // int32 paramid = 3 [json_name = "paramid"]; void clear_paramid(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::Node* xpr_; int paramkind_; int32_t paramid_; uint32_t paramtype_; int32_t paramtypmod_; uint32_t paramcollid_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class Aggref final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.Aggref) */ { public: inline Aggref() : Aggref(nullptr) {} ~Aggref() override; explicit PROTOBUF_CONSTEXPR Aggref(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); Aggref(const Aggref& from); Aggref(Aggref&& from) noexcept : Aggref() { *this = ::std::move(from); } inline Aggref& operator=(const Aggref& from) { CopyFrom(from); return *this; } inline Aggref& operator=(Aggref&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_Aggref_default_instance_); } static constexpr int kIndexInFileMessages = 17; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(Aggref* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- Aggref* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Aggref& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const Aggref& from) { Aggref::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Aggref* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.Aggref"; } protected: explicit Aggref(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kAggargtypesFieldNumber = 7, kAggdirectargsFieldNumber = 8, kArgsFieldNumber = 9, kAggorderFieldNumber = 10, kAggdistinctFieldNumber = 11, kAggkindFieldNumber = 15, kXprFieldNumber = 1, kAggfilterFieldNumber = 12, kAggfnoidFieldNumber = 2, kAggtypeFieldNumber = 3, kAggcollidFieldNumber = 4, kInputcollidFieldNumber = 5, kAggtranstypeFieldNumber = 6, kAggstarFieldNumber = 13, kAggvariadicFieldNumber = 14, kAgglevelsupFieldNumber = 16, kAggsplitFieldNumber = 17, kAggnoFieldNumber = 18, kAggtransnoFieldNumber = 19, kLocationFieldNumber = 20, }; // repeated .pg_query.Node aggargtypes = 7 [json_name = "aggargtypes"]; int aggargtypes_size() const; private: int _internal_aggargtypes_size() const; public: void clear_aggargtypes(); ::pg_query::Node* mutable_aggargtypes(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_aggargtypes(); private: const ::pg_query::Node& _internal_aggargtypes(int index) const; ::pg_query::Node* _internal_add_aggargtypes(); public: const ::pg_query::Node& aggargtypes(int index) const; ::pg_query::Node* add_aggargtypes(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& aggargtypes() const; // repeated .pg_query.Node aggdirectargs = 8 [json_name = "aggdirectargs"]; int aggdirectargs_size() const; private: int _internal_aggdirectargs_size() const; public: void clear_aggdirectargs(); ::pg_query::Node* mutable_aggdirectargs(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_aggdirectargs(); private: const ::pg_query::Node& _internal_aggdirectargs(int index) const; ::pg_query::Node* _internal_add_aggdirectargs(); public: const ::pg_query::Node& aggdirectargs(int index) const; ::pg_query::Node* add_aggdirectargs(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& aggdirectargs() const; // repeated .pg_query.Node args = 9 [json_name = "args"]; int args_size() const; private: int _internal_args_size() const; public: void clear_args(); ::pg_query::Node* mutable_args(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_args(); private: const ::pg_query::Node& _internal_args(int index) const; ::pg_query::Node* _internal_add_args(); public: const ::pg_query::Node& args(int index) const; ::pg_query::Node* add_args(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& args() const; // repeated .pg_query.Node aggorder = 10 [json_name = "aggorder"]; int aggorder_size() const; private: int _internal_aggorder_size() const; public: void clear_aggorder(); ::pg_query::Node* mutable_aggorder(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_aggorder(); private: const ::pg_query::Node& _internal_aggorder(int index) const; ::pg_query::Node* _internal_add_aggorder(); public: const ::pg_query::Node& aggorder(int index) const; ::pg_query::Node* add_aggorder(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& aggorder() const; // repeated .pg_query.Node aggdistinct = 11 [json_name = "aggdistinct"]; int aggdistinct_size() const; private: int _internal_aggdistinct_size() const; public: void clear_aggdistinct(); ::pg_query::Node* mutable_aggdistinct(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_aggdistinct(); private: const ::pg_query::Node& _internal_aggdistinct(int index) const; ::pg_query::Node* _internal_add_aggdistinct(); public: const ::pg_query::Node& aggdistinct(int index) const; ::pg_query::Node* add_aggdistinct(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& aggdistinct() const; // string aggkind = 15 [json_name = "aggkind"]; void clear_aggkind(); const std::string& aggkind() const; template void set_aggkind(ArgT0&& arg0, ArgT... args); std::string* mutable_aggkind(); PROTOBUF_NODISCARD std::string* release_aggkind(); void set_allocated_aggkind(std::string* aggkind); 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; private: bool _internal_has_xpr() const; public: 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* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // .pg_query.Node aggfilter = 12 [json_name = "aggfilter"]; bool has_aggfilter() const; private: bool _internal_has_aggfilter() const; public: void clear_aggfilter(); const ::pg_query::Node& aggfilter() const; PROTOBUF_NODISCARD ::pg_query::Node* release_aggfilter(); ::pg_query::Node* mutable_aggfilter(); void set_allocated_aggfilter(::pg_query::Node* aggfilter); private: const ::pg_query::Node& _internal_aggfilter() const; ::pg_query::Node* _internal_mutable_aggfilter(); public: void unsafe_arena_set_allocated_aggfilter( ::pg_query::Node* aggfilter); ::pg_query::Node* unsafe_arena_release_aggfilter(); // uint32 aggfnoid = 2 [json_name = "aggfnoid"]; void clear_aggfnoid(); 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: // uint32 aggtranstype = 6 [json_name = "aggtranstype"]; void clear_aggtranstype(); uint32_t aggtranstype() const; void set_aggtranstype(uint32_t value); private: uint32_t _internal_aggtranstype() const; void _internal_set_aggtranstype(uint32_t value); public: // bool aggstar = 13 [json_name = "aggstar"]; void clear_aggstar(); bool aggstar() const; void set_aggstar(bool value); private: bool _internal_aggstar() const; void _internal_set_aggstar(bool value); public: // bool aggvariadic = 14 [json_name = "aggvariadic"]; void clear_aggvariadic(); bool aggvariadic() const; void set_aggvariadic(bool value); private: bool _internal_aggvariadic() const; void _internal_set_aggvariadic(bool value); public: // uint32 agglevelsup = 16 [json_name = "agglevelsup"]; void clear_agglevelsup(); 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 = 17 [json_name = "aggsplit"]; void clear_aggsplit(); ::pg_query::AggSplit aggsplit() const; void set_aggsplit(::pg_query::AggSplit value); private: ::pg_query::AggSplit _internal_aggsplit() const; void _internal_set_aggsplit(::pg_query::AggSplit value); public: // int32 aggno = 18 [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 = 19 [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 = 20 [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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > aggargtypes_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > aggdirectargs_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > aggorder_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > aggdistinct_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr aggkind_; ::pg_query::Node* xpr_; ::pg_query::Node* aggfilter_; uint32_t aggfnoid_; uint32_t aggtype_; uint32_t aggcollid_; uint32_t inputcollid_; uint32_t aggtranstype_; bool aggstar_; bool aggvariadic_; uint32_t agglevelsup_; int aggsplit_; int32_t aggno_; int32_t aggtransno_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class GroupingFunc final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.GroupingFunc) */ { public: inline GroupingFunc() : GroupingFunc(nullptr) {} ~GroupingFunc() override; explicit PROTOBUF_CONSTEXPR GroupingFunc(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); GroupingFunc(const GroupingFunc& from); GroupingFunc(GroupingFunc&& from) noexcept : GroupingFunc() { *this = ::std::move(from); } inline GroupingFunc& operator=(const GroupingFunc& from) { CopyFrom(from); return *this; } inline GroupingFunc& operator=(GroupingFunc&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_GroupingFunc_default_instance_); } static constexpr int kIndexInFileMessages = 18; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(GroupingFunc* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- GroupingFunc* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const GroupingFunc& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const GroupingFunc& from) { GroupingFunc::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(GroupingFunc* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.GroupingFunc"; } protected: explicit GroupingFunc(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kArgsFieldNumber = 2, kRefsFieldNumber = 3, kColsFieldNumber = 4, kXprFieldNumber = 1, kAgglevelsupFieldNumber = 5, kLocationFieldNumber = 6, }; // repeated .pg_query.Node args = 2 [json_name = "args"]; int args_size() const; private: int _internal_args_size() const; public: void clear_args(); ::pg_query::Node* mutable_args(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_args(); private: const ::pg_query::Node& _internal_args(int index) const; ::pg_query::Node* _internal_add_args(); public: const ::pg_query::Node& args(int index) const; ::pg_query::Node* add_args(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& args() const; // repeated .pg_query.Node refs = 3 [json_name = "refs"]; int refs_size() const; private: int _internal_refs_size() const; public: void clear_refs(); ::pg_query::Node* mutable_refs(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_refs(); private: const ::pg_query::Node& _internal_refs(int index) const; ::pg_query::Node* _internal_add_refs(); public: const ::pg_query::Node& refs(int index) const; ::pg_query::Node* add_refs(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& refs() const; // repeated .pg_query.Node cols = 4 [json_name = "cols"]; int cols_size() const; private: int _internal_cols_size() const; public: void clear_cols(); ::pg_query::Node* mutable_cols(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_cols(); private: const ::pg_query::Node& _internal_cols(int index) const; ::pg_query::Node* _internal_add_cols(); public: const ::pg_query::Node& cols(int index) const; ::pg_query::Node* add_cols(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& cols() const; // .pg_query.Node xpr = 1 [json_name = "xpr"]; bool has_xpr() const; private: bool _internal_has_xpr() const; public: void clear_xpr(); const ::pg_query::Node& xpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_xpr(); ::pg_query::Node* mutable_xpr(); void set_allocated_xpr(::pg_query::Node* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // uint32 agglevelsup = 5 [json_name = "agglevelsup"]; void clear_agglevelsup(); 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 = 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.GroupingFunc) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > refs_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > cols_; ::pg_query::Node* xpr_; uint32_t agglevelsup_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class WindowFunc final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.WindowFunc) */ { public: inline WindowFunc() : WindowFunc(nullptr) {} ~WindowFunc() override; explicit PROTOBUF_CONSTEXPR WindowFunc(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); WindowFunc(const WindowFunc& from); WindowFunc(WindowFunc&& from) noexcept : WindowFunc() { *this = ::std::move(from); } inline WindowFunc& operator=(const WindowFunc& from) { CopyFrom(from); return *this; } inline WindowFunc& operator=(WindowFunc&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_WindowFunc_default_instance_); } static constexpr int kIndexInFileMessages = 19; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(WindowFunc* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- WindowFunc* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const WindowFunc& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const WindowFunc& from) { WindowFunc::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(WindowFunc* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.WindowFunc"; } protected: explicit WindowFunc(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_args(); private: const ::pg_query::Node& _internal_args(int index) const; ::pg_query::Node* _internal_add_args(); public: const ::pg_query::Node& args(int index) const; ::pg_query::Node* add_args(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& args() const; // .pg_query.Node xpr = 1 [json_name = "xpr"]; bool has_xpr() const; private: bool _internal_has_xpr() const; public: void clear_xpr(); const ::pg_query::Node& xpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_xpr(); ::pg_query::Node* mutable_xpr(); void set_allocated_xpr(::pg_query::Node* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // .pg_query.Node aggfilter = 7 [json_name = "aggfilter"]; bool has_aggfilter() const; private: bool _internal_has_aggfilter() const; public: void clear_aggfilter(); const ::pg_query::Node& aggfilter() const; PROTOBUF_NODISCARD ::pg_query::Node* release_aggfilter(); ::pg_query::Node* mutable_aggfilter(); void set_allocated_aggfilter(::pg_query::Node* aggfilter); private: const ::pg_query::Node& _internal_aggfilter() const; ::pg_query::Node* _internal_mutable_aggfilter(); public: void unsafe_arena_set_allocated_aggfilter( ::pg_query::Node* aggfilter); ::pg_query::Node* unsafe_arena_release_aggfilter(); // uint32 winfnoid = 2 [json_name = "winfnoid"]; void clear_winfnoid(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::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_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class SubscriptingRef final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.SubscriptingRef) */ { public: inline SubscriptingRef() : SubscriptingRef(nullptr) {} ~SubscriptingRef() override; explicit PROTOBUF_CONSTEXPR SubscriptingRef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); SubscriptingRef(const SubscriptingRef& from); SubscriptingRef(SubscriptingRef&& from) noexcept : SubscriptingRef() { *this = ::std::move(from); } inline SubscriptingRef& operator=(const SubscriptingRef& from) { CopyFrom(from); return *this; } inline SubscriptingRef& operator=(SubscriptingRef&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_SubscriptingRef_default_instance_); } static constexpr int kIndexInFileMessages = 20; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SubscriptingRef* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- SubscriptingRef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const SubscriptingRef& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const SubscriptingRef& from) { SubscriptingRef::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(SubscriptingRef* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.SubscriptingRef"; } protected: explicit SubscriptingRef(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_refupperindexpr(); private: const ::pg_query::Node& _internal_refupperindexpr(int index) const; ::pg_query::Node* _internal_add_refupperindexpr(); public: const ::pg_query::Node& refupperindexpr(int index) const; ::pg_query::Node* add_refupperindexpr(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& refupperindexpr() const; // repeated .pg_query.Node reflowerindexpr = 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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_reflowerindexpr(); private: const ::pg_query::Node& _internal_reflowerindexpr(int index) const; ::pg_query::Node* _internal_add_reflowerindexpr(); public: const ::pg_query::Node& reflowerindexpr(int index) const; ::pg_query::Node* add_reflowerindexpr(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& reflowerindexpr() const; // .pg_query.Node xpr = 1 [json_name = "xpr"]; bool has_xpr() const; private: bool _internal_has_xpr() const; public: void clear_xpr(); const ::pg_query::Node& xpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_xpr(); ::pg_query::Node* mutable_xpr(); void set_allocated_xpr(::pg_query::Node* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // .pg_query.Node refexpr = 9 [json_name = "refexpr"]; bool has_refexpr() const; private: bool _internal_has_refexpr() const; public: 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* refexpr); private: const ::pg_query::Node& _internal_refexpr() const; ::pg_query::Node* _internal_mutable_refexpr(); public: void unsafe_arena_set_allocated_refexpr( ::pg_query::Node* refexpr); ::pg_query::Node* unsafe_arena_release_refexpr(); // .pg_query.Node refassgnexpr = 10 [json_name = "refassgnexpr"]; bool has_refassgnexpr() const; private: bool _internal_has_refassgnexpr() const; public: 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* refassgnexpr); private: const ::pg_query::Node& _internal_refassgnexpr() const; ::pg_query::Node* _internal_mutable_refassgnexpr(); public: void unsafe_arena_set_allocated_refassgnexpr( ::pg_query::Node* refassgnexpr); ::pg_query::Node* unsafe_arena_release_refassgnexpr(); // uint32 refcontainertype = 2 [json_name = "refcontainertype"]; void clear_refcontainertype(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > refupperindexpr_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > reflowerindexpr_; ::pg_query::Node* xpr_; ::pg_query::Node* refexpr_; ::pg_query::Node* refassgnexpr_; uint32_t refcontainertype_; uint32_t refelemtype_; uint32_t refrestype_; int32_t reftypmod_; uint32_t refcollid_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class FuncExpr final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.FuncExpr) */ { public: inline FuncExpr() : FuncExpr(nullptr) {} ~FuncExpr() override; explicit PROTOBUF_CONSTEXPR FuncExpr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); FuncExpr(const FuncExpr& from); FuncExpr(FuncExpr&& from) noexcept : FuncExpr() { *this = ::std::move(from); } inline FuncExpr& operator=(const FuncExpr& from) { CopyFrom(from); return *this; } inline FuncExpr& operator=(FuncExpr&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_FuncExpr_default_instance_); } static constexpr int kIndexInFileMessages = 21; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(FuncExpr* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- FuncExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const FuncExpr& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const FuncExpr& from) { FuncExpr::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(FuncExpr* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.FuncExpr"; } protected: explicit FuncExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_args(); private: const ::pg_query::Node& _internal_args(int index) const; ::pg_query::Node* _internal_add_args(); public: const ::pg_query::Node& args(int index) const; ::pg_query::Node* add_args(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& args() const; // .pg_query.Node xpr = 1 [json_name = "xpr"]; bool has_xpr() const; private: bool _internal_has_xpr() const; public: void clear_xpr(); const ::pg_query::Node& xpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_xpr(); ::pg_query::Node* mutable_xpr(); void set_allocated_xpr(::pg_query::Node* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // uint32 funcid = 2 [json_name = "funcid"]; void clear_funcid(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::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_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class NamedArgExpr final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.NamedArgExpr) */ { public: inline NamedArgExpr() : NamedArgExpr(nullptr) {} ~NamedArgExpr() override; explicit PROTOBUF_CONSTEXPR NamedArgExpr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); NamedArgExpr(const NamedArgExpr& from); NamedArgExpr(NamedArgExpr&& from) noexcept : NamedArgExpr() { *this = ::std::move(from); } inline NamedArgExpr& operator=(const NamedArgExpr& from) { CopyFrom(from); return *this; } inline NamedArgExpr& operator=(NamedArgExpr&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_NamedArgExpr_default_instance_); } static constexpr int kIndexInFileMessages = 22; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(NamedArgExpr* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- NamedArgExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const NamedArgExpr& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const NamedArgExpr& from) { NamedArgExpr::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(NamedArgExpr* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.NamedArgExpr"; } protected: explicit NamedArgExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); 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; private: bool _internal_has_xpr() const; public: 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* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // .pg_query.Node arg = 2 [json_name = "arg"]; bool has_arg() const; private: bool _internal_has_arg() const; public: void clear_arg(); const ::pg_query::Node& arg() const; PROTOBUF_NODISCARD ::pg_query::Node* release_arg(); ::pg_query::Node* mutable_arg(); void set_allocated_arg(::pg_query::Node* arg); private: const ::pg_query::Node& _internal_arg() const; ::pg_query::Node* _internal_mutable_arg(); public: void unsafe_arena_set_allocated_arg( ::pg_query::Node* arg); ::pg_query::Node* unsafe_arena_release_arg(); // int32 argnumber = 4 [json_name = "argnumber"]; void clear_argnumber(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; ::pg_query::Node* xpr_; ::pg_query::Node* arg_; int32_t argnumber_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class OpExpr final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.OpExpr) */ { public: inline OpExpr() : OpExpr(nullptr) {} ~OpExpr() override; explicit PROTOBUF_CONSTEXPR OpExpr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); OpExpr(const OpExpr& from); OpExpr(OpExpr&& from) noexcept : OpExpr() { *this = ::std::move(from); } inline OpExpr& operator=(const OpExpr& from) { CopyFrom(from); return *this; } inline OpExpr& operator=(OpExpr&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_OpExpr_default_instance_); } static constexpr int kIndexInFileMessages = 23; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(OpExpr* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- OpExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const OpExpr& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const OpExpr& from) { OpExpr::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(OpExpr* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.OpExpr"; } protected: explicit OpExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kArgsFieldNumber = 8, kXprFieldNumber = 1, kOpnoFieldNumber = 2, kOpfuncidFieldNumber = 3, kOpresulttypeFieldNumber = 4, kOpretsetFieldNumber = 5, kOpcollidFieldNumber = 6, kInputcollidFieldNumber = 7, kLocationFieldNumber = 9, }; // repeated .pg_query.Node args = 8 [json_name = "args"]; int args_size() const; private: int _internal_args_size() const; public: void clear_args(); ::pg_query::Node* mutable_args(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_args(); private: const ::pg_query::Node& _internal_args(int index) const; ::pg_query::Node* _internal_add_args(); public: const ::pg_query::Node& args(int index) const; ::pg_query::Node* add_args(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& args() const; // .pg_query.Node xpr = 1 [json_name = "xpr"]; bool has_xpr() const; private: bool _internal_has_xpr() const; public: void clear_xpr(); const ::pg_query::Node& xpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_xpr(); ::pg_query::Node* mutable_xpr(); void set_allocated_xpr(::pg_query::Node* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // uint32 opno = 2 [json_name = "opno"]; void clear_opno(); 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 opfuncid = 3 [json_name = "opfuncid"]; void clear_opfuncid(); uint32_t opfuncid() const; void set_opfuncid(uint32_t value); private: uint32_t _internal_opfuncid() const; void _internal_set_opfuncid(uint32_t value); public: // uint32 opresulttype = 4 [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 = 5 [json_name = "opretset"]; void clear_opretset(); bool opretset() const; void set_opretset(bool value); private: bool _internal_opretset() const; void _internal_set_opretset(bool value); public: // uint32 opcollid = 6 [json_name = "opcollid"]; void clear_opcollid(); 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 = 7 [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 = 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.OpExpr) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_; ::pg_query::Node* xpr_; uint32_t opno_; uint32_t opfuncid_; uint32_t opresulttype_; bool opretset_; uint32_t opcollid_; uint32_t inputcollid_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class DistinctExpr final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DistinctExpr) */ { public: inline DistinctExpr() : DistinctExpr(nullptr) {} ~DistinctExpr() override; explicit PROTOBUF_CONSTEXPR DistinctExpr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); DistinctExpr(const DistinctExpr& from); DistinctExpr(DistinctExpr&& from) noexcept : DistinctExpr() { *this = ::std::move(from); } inline DistinctExpr& operator=(const DistinctExpr& from) { CopyFrom(from); return *this; } inline DistinctExpr& operator=(DistinctExpr&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_DistinctExpr_default_instance_); } static constexpr int kIndexInFileMessages = 24; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(DistinctExpr* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- DistinctExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DistinctExpr& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const DistinctExpr& from) { DistinctExpr::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DistinctExpr* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.DistinctExpr"; } protected: explicit DistinctExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kArgsFieldNumber = 8, kXprFieldNumber = 1, kOpnoFieldNumber = 2, kOpfuncidFieldNumber = 3, kOpresulttypeFieldNumber = 4, kOpretsetFieldNumber = 5, kOpcollidFieldNumber = 6, kInputcollidFieldNumber = 7, kLocationFieldNumber = 9, }; // repeated .pg_query.Node args = 8 [json_name = "args"]; int args_size() const; private: int _internal_args_size() const; public: void clear_args(); ::pg_query::Node* mutable_args(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_args(); private: const ::pg_query::Node& _internal_args(int index) const; ::pg_query::Node* _internal_add_args(); public: const ::pg_query::Node& args(int index) const; ::pg_query::Node* add_args(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& args() const; // .pg_query.Node xpr = 1 [json_name = "xpr"]; bool has_xpr() const; private: bool _internal_has_xpr() const; public: void clear_xpr(); const ::pg_query::Node& xpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_xpr(); ::pg_query::Node* mutable_xpr(); void set_allocated_xpr(::pg_query::Node* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // uint32 opno = 2 [json_name = "opno"]; void clear_opno(); 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 opfuncid = 3 [json_name = "opfuncid"]; void clear_opfuncid(); uint32_t opfuncid() const; void set_opfuncid(uint32_t value); private: uint32_t _internal_opfuncid() const; void _internal_set_opfuncid(uint32_t value); public: // uint32 opresulttype = 4 [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 = 5 [json_name = "opretset"]; void clear_opretset(); bool opretset() const; void set_opretset(bool value); private: bool _internal_opretset() const; void _internal_set_opretset(bool value); public: // uint32 opcollid = 6 [json_name = "opcollid"]; void clear_opcollid(); 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 = 7 [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 = 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.DistinctExpr) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_; ::pg_query::Node* xpr_; uint32_t opno_; uint32_t opfuncid_; uint32_t opresulttype_; bool opretset_; uint32_t opcollid_; uint32_t inputcollid_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class NullIfExpr final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.NullIfExpr) */ { public: inline NullIfExpr() : NullIfExpr(nullptr) {} ~NullIfExpr() override; explicit PROTOBUF_CONSTEXPR NullIfExpr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); NullIfExpr(const NullIfExpr& from); NullIfExpr(NullIfExpr&& from) noexcept : NullIfExpr() { *this = ::std::move(from); } inline NullIfExpr& operator=(const NullIfExpr& from) { CopyFrom(from); return *this; } inline NullIfExpr& operator=(NullIfExpr&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_NullIfExpr_default_instance_); } static constexpr int kIndexInFileMessages = 25; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(NullIfExpr* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- NullIfExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const NullIfExpr& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const NullIfExpr& from) { NullIfExpr::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(NullIfExpr* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.NullIfExpr"; } protected: explicit NullIfExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kArgsFieldNumber = 8, kXprFieldNumber = 1, kOpnoFieldNumber = 2, kOpfuncidFieldNumber = 3, kOpresulttypeFieldNumber = 4, kOpretsetFieldNumber = 5, kOpcollidFieldNumber = 6, kInputcollidFieldNumber = 7, kLocationFieldNumber = 9, }; // repeated .pg_query.Node args = 8 [json_name = "args"]; int args_size() const; private: int _internal_args_size() const; public: void clear_args(); ::pg_query::Node* mutable_args(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_args(); private: const ::pg_query::Node& _internal_args(int index) const; ::pg_query::Node* _internal_add_args(); public: const ::pg_query::Node& args(int index) const; ::pg_query::Node* add_args(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& args() const; // .pg_query.Node xpr = 1 [json_name = "xpr"]; bool has_xpr() const; private: bool _internal_has_xpr() const; public: void clear_xpr(); const ::pg_query::Node& xpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_xpr(); ::pg_query::Node* mutable_xpr(); void set_allocated_xpr(::pg_query::Node* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // uint32 opno = 2 [json_name = "opno"]; void clear_opno(); 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 opfuncid = 3 [json_name = "opfuncid"]; void clear_opfuncid(); uint32_t opfuncid() const; void set_opfuncid(uint32_t value); private: uint32_t _internal_opfuncid() const; void _internal_set_opfuncid(uint32_t value); public: // uint32 opresulttype = 4 [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 = 5 [json_name = "opretset"]; void clear_opretset(); bool opretset() const; void set_opretset(bool value); private: bool _internal_opretset() const; void _internal_set_opretset(bool value); public: // uint32 opcollid = 6 [json_name = "opcollid"]; void clear_opcollid(); 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 = 7 [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 = 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.NullIfExpr) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_; ::pg_query::Node* xpr_; uint32_t opno_; uint32_t opfuncid_; uint32_t opresulttype_; bool opretset_; uint32_t opcollid_; uint32_t inputcollid_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class ScalarArrayOpExpr final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ScalarArrayOpExpr) */ { public: inline ScalarArrayOpExpr() : ScalarArrayOpExpr(nullptr) {} ~ScalarArrayOpExpr() override; explicit PROTOBUF_CONSTEXPR ScalarArrayOpExpr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ScalarArrayOpExpr(const ScalarArrayOpExpr& from); ScalarArrayOpExpr(ScalarArrayOpExpr&& from) noexcept : ScalarArrayOpExpr() { *this = ::std::move(from); } inline ScalarArrayOpExpr& operator=(const ScalarArrayOpExpr& from) { CopyFrom(from); return *this; } inline ScalarArrayOpExpr& operator=(ScalarArrayOpExpr&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_ScalarArrayOpExpr_default_instance_); } static constexpr int kIndexInFileMessages = 26; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ScalarArrayOpExpr* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ScalarArrayOpExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ScalarArrayOpExpr& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ScalarArrayOpExpr& from) { ScalarArrayOpExpr::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ScalarArrayOpExpr* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.ScalarArrayOpExpr"; } protected: explicit ScalarArrayOpExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kArgsFieldNumber = 8, kXprFieldNumber = 1, kOpnoFieldNumber = 2, kOpfuncidFieldNumber = 3, kHashfuncidFieldNumber = 4, kNegfuncidFieldNumber = 5, kUseOrFieldNumber = 6, kInputcollidFieldNumber = 7, kLocationFieldNumber = 9, }; // repeated .pg_query.Node args = 8 [json_name = "args"]; int args_size() const; private: int _internal_args_size() const; public: void clear_args(); ::pg_query::Node* mutable_args(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_args(); private: const ::pg_query::Node& _internal_args(int index) const; ::pg_query::Node* _internal_add_args(); public: const ::pg_query::Node& args(int index) const; ::pg_query::Node* add_args(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& args() const; // .pg_query.Node xpr = 1 [json_name = "xpr"]; bool has_xpr() const; private: bool _internal_has_xpr() const; public: void clear_xpr(); const ::pg_query::Node& xpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_xpr(); ::pg_query::Node* mutable_xpr(); void set_allocated_xpr(::pg_query::Node* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // uint32 opno = 2 [json_name = "opno"]; void clear_opno(); 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 opfuncid = 3 [json_name = "opfuncid"]; void clear_opfuncid(); uint32_t opfuncid() const; void set_opfuncid(uint32_t value); private: uint32_t _internal_opfuncid() const; void _internal_set_opfuncid(uint32_t value); public: // uint32 hashfuncid = 4 [json_name = "hashfuncid"]; void clear_hashfuncid(); uint32_t hashfuncid() const; void set_hashfuncid(uint32_t value); private: uint32_t _internal_hashfuncid() const; void _internal_set_hashfuncid(uint32_t value); public: // uint32 negfuncid = 5 [json_name = "negfuncid"]; void clear_negfuncid(); uint32_t negfuncid() const; void set_negfuncid(uint32_t value); private: uint32_t _internal_negfuncid() const; void _internal_set_negfuncid(uint32_t value); public: // bool use_or = 6 [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 = 7 [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 = 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.ScalarArrayOpExpr) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_; ::pg_query::Node* xpr_; uint32_t opno_; uint32_t opfuncid_; uint32_t hashfuncid_; uint32_t negfuncid_; bool use_or_; uint32_t inputcollid_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class BoolExpr final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.BoolExpr) */ { public: inline BoolExpr() : BoolExpr(nullptr) {} ~BoolExpr() override; explicit PROTOBUF_CONSTEXPR BoolExpr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); BoolExpr(const BoolExpr& from); BoolExpr(BoolExpr&& from) noexcept : BoolExpr() { *this = ::std::move(from); } inline BoolExpr& operator=(const BoolExpr& from) { CopyFrom(from); return *this; } inline BoolExpr& operator=(BoolExpr&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_BoolExpr_default_instance_); } static constexpr int kIndexInFileMessages = 27; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(BoolExpr* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- BoolExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const BoolExpr& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const BoolExpr& from) { BoolExpr::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(BoolExpr* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.BoolExpr"; } protected: explicit BoolExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_args(); private: const ::pg_query::Node& _internal_args(int index) const; ::pg_query::Node* _internal_add_args(); public: const ::pg_query::Node& args(int index) const; ::pg_query::Node* add_args(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& args() const; // .pg_query.Node xpr = 1 [json_name = "xpr"]; bool has_xpr() const; private: bool _internal_has_xpr() const; public: void clear_xpr(); const ::pg_query::Node& xpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_xpr(); ::pg_query::Node* mutable_xpr(); void set_allocated_xpr(::pg_query::Node* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // .pg_query.BoolExprType boolop = 2 [json_name = "boolop"]; void clear_boolop(); ::pg_query::BoolExprType boolop() const; void set_boolop(::pg_query::BoolExprType value); private: ::pg_query::BoolExprType _internal_boolop() const; void _internal_set_boolop(::pg_query::BoolExprType value); public: // int32 location = 4 [json_name = "location"]; void clear_location(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_; ::pg_query::Node* xpr_; int boolop_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class SubLink final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.SubLink) */ { public: inline SubLink() : SubLink(nullptr) {} ~SubLink() override; explicit PROTOBUF_CONSTEXPR SubLink(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); SubLink(const SubLink& from); SubLink(SubLink&& from) noexcept : SubLink() { *this = ::std::move(from); } inline SubLink& operator=(const SubLink& from) { CopyFrom(from); return *this; } inline SubLink& operator=(SubLink&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_SubLink_default_instance_); } static constexpr int kIndexInFileMessages = 28; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SubLink* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- SubLink* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const SubLink& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const SubLink& from) { SubLink::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(SubLink* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.SubLink"; } protected: explicit SubLink(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_oper_name(); private: const ::pg_query::Node& _internal_oper_name(int index) const; ::pg_query::Node* _internal_add_oper_name(); public: const ::pg_query::Node& oper_name(int index) const; ::pg_query::Node* add_oper_name(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& oper_name() const; // .pg_query.Node xpr = 1 [json_name = "xpr"]; bool has_xpr() const; private: bool _internal_has_xpr() const; public: void clear_xpr(); const ::pg_query::Node& xpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_xpr(); ::pg_query::Node* mutable_xpr(); void set_allocated_xpr(::pg_query::Node* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // .pg_query.Node testexpr = 4 [json_name = "testexpr"]; bool has_testexpr() const; private: bool _internal_has_testexpr() const; public: void clear_testexpr(); const ::pg_query::Node& testexpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_testexpr(); ::pg_query::Node* mutable_testexpr(); void set_allocated_testexpr(::pg_query::Node* testexpr); private: const ::pg_query::Node& _internal_testexpr() const; ::pg_query::Node* _internal_mutable_testexpr(); public: void unsafe_arena_set_allocated_testexpr( ::pg_query::Node* testexpr); ::pg_query::Node* unsafe_arena_release_testexpr(); // .pg_query.Node subselect = 6 [json_name = "subselect"]; bool has_subselect() const; private: bool _internal_has_subselect() const; public: void clear_subselect(); const ::pg_query::Node& subselect() const; PROTOBUF_NODISCARD ::pg_query::Node* release_subselect(); ::pg_query::Node* mutable_subselect(); void set_allocated_subselect(::pg_query::Node* subselect); private: const ::pg_query::Node& _internal_subselect() const; ::pg_query::Node* _internal_mutable_subselect(); public: void unsafe_arena_set_allocated_subselect( ::pg_query::Node* subselect); ::pg_query::Node* unsafe_arena_release_subselect(); // .pg_query.SubLinkType sub_link_type = 2 [json_name = "subLinkType"]; void clear_sub_link_type(); ::pg_query::SubLinkType sub_link_type() const; void set_sub_link_type(::pg_query::SubLinkType value); private: ::pg_query::SubLinkType _internal_sub_link_type() const; void _internal_set_sub_link_type(::pg_query::SubLinkType value); public: // int32 sub_link_id = 3 [json_name = "subLinkId"]; void clear_sub_link_id(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > oper_name_; ::pg_query::Node* xpr_; ::pg_query::Node* testexpr_; ::pg_query::Node* subselect_; int sub_link_type_; int32_t sub_link_id_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class SubPlan final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.SubPlan) */ { public: inline SubPlan() : SubPlan(nullptr) {} ~SubPlan() override; explicit PROTOBUF_CONSTEXPR SubPlan(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); SubPlan(const SubPlan& from); SubPlan(SubPlan&& from) noexcept : SubPlan() { *this = ::std::move(from); } inline SubPlan& operator=(const SubPlan& from) { CopyFrom(from); return *this; } inline SubPlan& operator=(SubPlan&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_SubPlan_default_instance_); } static constexpr int kIndexInFileMessages = 29; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SubPlan* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- SubPlan* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const SubPlan& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const SubPlan& from) { SubPlan::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(SubPlan* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.SubPlan"; } protected: explicit SubPlan(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_param_ids(); private: const ::pg_query::Node& _internal_param_ids(int index) const; ::pg_query::Node* _internal_add_param_ids(); public: const ::pg_query::Node& param_ids(int index) const; ::pg_query::Node* add_param_ids(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& param_ids() const; // repeated .pg_query.Node set_param = 13 [json_name = "setParam"]; int set_param_size() const; private: int _internal_set_param_size() const; public: void clear_set_param(); ::pg_query::Node* mutable_set_param(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_set_param(); private: const ::pg_query::Node& _internal_set_param(int index) const; ::pg_query::Node* _internal_add_set_param(); public: const ::pg_query::Node& set_param(int index) const; ::pg_query::Node* add_set_param(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& set_param() const; // repeated .pg_query.Node par_param = 14 [json_name = "parParam"]; int par_param_size() const; private: int _internal_par_param_size() const; public: void clear_par_param(); ::pg_query::Node* mutable_par_param(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_par_param(); private: const ::pg_query::Node& _internal_par_param(int index) const; ::pg_query::Node* _internal_add_par_param(); public: const ::pg_query::Node& par_param(int index) const; ::pg_query::Node* add_par_param(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& par_param() const; // repeated .pg_query.Node args = 15 [json_name = "args"]; int args_size() const; private: int _internal_args_size() const; public: void clear_args(); ::pg_query::Node* mutable_args(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_args(); private: const ::pg_query::Node& _internal_args(int index) const; ::pg_query::Node* _internal_add_args(); public: const ::pg_query::Node& args(int index) const; ::pg_query::Node* add_args(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& args() const; // string plan_name = 6 [json_name = "plan_name"]; void clear_plan_name(); const std::string& plan_name() const; template void set_plan_name(ArgT0&& arg0, ArgT... args); std::string* mutable_plan_name(); PROTOBUF_NODISCARD std::string* release_plan_name(); void set_allocated_plan_name(std::string* plan_name); 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; private: bool _internal_has_xpr() const; public: 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* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // .pg_query.Node testexpr = 3 [json_name = "testexpr"]; bool has_testexpr() const; private: bool _internal_has_testexpr() const; public: void clear_testexpr(); const ::pg_query::Node& testexpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_testexpr(); ::pg_query::Node* mutable_testexpr(); void set_allocated_testexpr(::pg_query::Node* testexpr); private: const ::pg_query::Node& _internal_testexpr() const; ::pg_query::Node* _internal_mutable_testexpr(); public: void unsafe_arena_set_allocated_testexpr( ::pg_query::Node* testexpr); ::pg_query::Node* unsafe_arena_release_testexpr(); // .pg_query.SubLinkType sub_link_type = 2 [json_name = "subLinkType"]; void clear_sub_link_type(); ::pg_query::SubLinkType sub_link_type() const; void set_sub_link_type(::pg_query::SubLinkType value); private: ::pg_query::SubLinkType _internal_sub_link_type() const; void _internal_set_sub_link_type(::pg_query::SubLinkType value); public: // int32 plan_id = 5 [json_name = "plan_id"]; void clear_plan_id(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > param_ids_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > set_param_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > par_param_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr plan_name_; ::pg_query::Node* xpr_; ::pg_query::Node* testexpr_; int sub_link_type_; 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_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlternativeSubPlan final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlternativeSubPlan) */ { public: inline AlternativeSubPlan() : AlternativeSubPlan(nullptr) {} ~AlternativeSubPlan() override; explicit PROTOBUF_CONSTEXPR AlternativeSubPlan(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlternativeSubPlan(const AlternativeSubPlan& from); AlternativeSubPlan(AlternativeSubPlan&& from) noexcept : AlternativeSubPlan() { *this = ::std::move(from); } inline AlternativeSubPlan& operator=(const AlternativeSubPlan& from) { CopyFrom(from); return *this; } inline AlternativeSubPlan& operator=(AlternativeSubPlan&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlternativeSubPlan_default_instance_); } static constexpr int kIndexInFileMessages = 30; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlternativeSubPlan* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlternativeSubPlan* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlternativeSubPlan& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlternativeSubPlan& from) { AlternativeSubPlan::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlternativeSubPlan* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlternativeSubPlan"; } protected: explicit AlternativeSubPlan(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_subplans(); private: const ::pg_query::Node& _internal_subplans(int index) const; ::pg_query::Node* _internal_add_subplans(); public: const ::pg_query::Node& subplans(int index) const; ::pg_query::Node* add_subplans(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& subplans() const; // .pg_query.Node xpr = 1 [json_name = "xpr"]; bool has_xpr() const; private: bool _internal_has_xpr() const; public: void clear_xpr(); const ::pg_query::Node& xpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_xpr(); ::pg_query::Node* mutable_xpr(); void set_allocated_xpr(::pg_query::Node* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // @@protoc_insertion_point(class_scope:pg_query.AlternativeSubPlan) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > subplans_; ::pg_query::Node* xpr_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class FieldSelect final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.FieldSelect) */ { public: inline FieldSelect() : FieldSelect(nullptr) {} ~FieldSelect() override; explicit PROTOBUF_CONSTEXPR FieldSelect(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); FieldSelect(const FieldSelect& from); FieldSelect(FieldSelect&& from) noexcept : FieldSelect() { *this = ::std::move(from); } inline FieldSelect& operator=(const FieldSelect& from) { CopyFrom(from); return *this; } inline FieldSelect& operator=(FieldSelect&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_FieldSelect_default_instance_); } static constexpr int kIndexInFileMessages = 31; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(FieldSelect* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- FieldSelect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const FieldSelect& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const FieldSelect& from) { FieldSelect::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(FieldSelect* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.FieldSelect"; } protected: explicit FieldSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_xpr() const; public: 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* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // .pg_query.Node arg = 2 [json_name = "arg"]; bool has_arg() const; private: bool _internal_has_arg() const; public: void clear_arg(); const ::pg_query::Node& arg() const; PROTOBUF_NODISCARD ::pg_query::Node* release_arg(); ::pg_query::Node* mutable_arg(); void set_allocated_arg(::pg_query::Node* arg); private: const ::pg_query::Node& _internal_arg() const; ::pg_query::Node* _internal_mutable_arg(); public: void unsafe_arena_set_allocated_arg( ::pg_query::Node* arg); ::pg_query::Node* unsafe_arena_release_arg(); // int32 fieldnum = 3 [json_name = "fieldnum"]; void clear_fieldnum(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::Node* xpr_; ::pg_query::Node* arg_; int32_t fieldnum_; uint32_t resulttype_; int32_t resulttypmod_; uint32_t resultcollid_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class FieldStore final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.FieldStore) */ { public: inline FieldStore() : FieldStore(nullptr) {} ~FieldStore() override; explicit PROTOBUF_CONSTEXPR FieldStore(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); FieldStore(const FieldStore& from); FieldStore(FieldStore&& from) noexcept : FieldStore() { *this = ::std::move(from); } inline FieldStore& operator=(const FieldStore& from) { CopyFrom(from); return *this; } inline FieldStore& operator=(FieldStore&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_FieldStore_default_instance_); } static constexpr int kIndexInFileMessages = 32; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(FieldStore* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- FieldStore* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const FieldStore& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const FieldStore& from) { FieldStore::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(FieldStore* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.FieldStore"; } protected: explicit FieldStore(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_newvals(); private: const ::pg_query::Node& _internal_newvals(int index) const; ::pg_query::Node* _internal_add_newvals(); public: const ::pg_query::Node& newvals(int index) const; ::pg_query::Node* add_newvals(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& newvals() const; // repeated .pg_query.Node fieldnums = 4 [json_name = "fieldnums"]; int fieldnums_size() const; private: int _internal_fieldnums_size() const; public: void clear_fieldnums(); ::pg_query::Node* mutable_fieldnums(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_fieldnums(); private: const ::pg_query::Node& _internal_fieldnums(int index) const; ::pg_query::Node* _internal_add_fieldnums(); public: const ::pg_query::Node& fieldnums(int index) const; ::pg_query::Node* add_fieldnums(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& fieldnums() const; // .pg_query.Node xpr = 1 [json_name = "xpr"]; bool has_xpr() const; private: bool _internal_has_xpr() const; public: void clear_xpr(); const ::pg_query::Node& xpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_xpr(); ::pg_query::Node* mutable_xpr(); void set_allocated_xpr(::pg_query::Node* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // .pg_query.Node arg = 2 [json_name = "arg"]; bool has_arg() const; private: bool _internal_has_arg() const; public: void clear_arg(); const ::pg_query::Node& arg() const; PROTOBUF_NODISCARD ::pg_query::Node* release_arg(); ::pg_query::Node* mutable_arg(); void set_allocated_arg(::pg_query::Node* arg); private: const ::pg_query::Node& _internal_arg() const; ::pg_query::Node* _internal_mutable_arg(); public: void unsafe_arena_set_allocated_arg( ::pg_query::Node* arg); ::pg_query::Node* unsafe_arena_release_arg(); // uint32 resulttype = 5 [json_name = "resulttype"]; void clear_resulttype(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > newvals_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > fieldnums_; ::pg_query::Node* xpr_; ::pg_query::Node* arg_; uint32_t resulttype_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class RelabelType final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RelabelType) */ { public: inline RelabelType() : RelabelType(nullptr) {} ~RelabelType() override; explicit PROTOBUF_CONSTEXPR RelabelType(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); RelabelType(const RelabelType& from); RelabelType(RelabelType&& from) noexcept : RelabelType() { *this = ::std::move(from); } inline RelabelType& operator=(const RelabelType& from) { CopyFrom(from); return *this; } inline RelabelType& operator=(RelabelType&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_RelabelType_default_instance_); } static constexpr int kIndexInFileMessages = 33; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(RelabelType* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- RelabelType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const RelabelType& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const RelabelType& from) { RelabelType::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(RelabelType* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.RelabelType"; } protected: explicit RelabelType(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_xpr() const; public: 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* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // .pg_query.Node arg = 2 [json_name = "arg"]; bool has_arg() const; private: bool _internal_has_arg() const; public: void clear_arg(); const ::pg_query::Node& arg() const; PROTOBUF_NODISCARD ::pg_query::Node* release_arg(); ::pg_query::Node* mutable_arg(); void set_allocated_arg(::pg_query::Node* arg); private: const ::pg_query::Node& _internal_arg() const; ::pg_query::Node* _internal_mutable_arg(); public: void unsafe_arena_set_allocated_arg( ::pg_query::Node* arg); ::pg_query::Node* unsafe_arena_release_arg(); // uint32 resulttype = 3 [json_name = "resulttype"]; void clear_resulttype(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::Node* xpr_; ::pg_query::Node* arg_; uint32_t resulttype_; int32_t resulttypmod_; uint32_t resultcollid_; int relabelformat_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CoerceViaIO final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CoerceViaIO) */ { public: inline CoerceViaIO() : CoerceViaIO(nullptr) {} ~CoerceViaIO() override; explicit PROTOBUF_CONSTEXPR CoerceViaIO(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CoerceViaIO(const CoerceViaIO& from); CoerceViaIO(CoerceViaIO&& from) noexcept : CoerceViaIO() { *this = ::std::move(from); } inline CoerceViaIO& operator=(const CoerceViaIO& from) { CopyFrom(from); return *this; } inline CoerceViaIO& operator=(CoerceViaIO&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CoerceViaIO_default_instance_); } static constexpr int kIndexInFileMessages = 34; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CoerceViaIO* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CoerceViaIO* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CoerceViaIO& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CoerceViaIO& from) { CoerceViaIO::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CoerceViaIO* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CoerceViaIO"; } protected: explicit CoerceViaIO(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_xpr() const; public: 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* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // .pg_query.Node arg = 2 [json_name = "arg"]; bool has_arg() const; private: bool _internal_has_arg() const; public: void clear_arg(); const ::pg_query::Node& arg() const; PROTOBUF_NODISCARD ::pg_query::Node* release_arg(); ::pg_query::Node* mutable_arg(); void set_allocated_arg(::pg_query::Node* arg); private: const ::pg_query::Node& _internal_arg() const; ::pg_query::Node* _internal_mutable_arg(); public: void unsafe_arena_set_allocated_arg( ::pg_query::Node* arg); ::pg_query::Node* unsafe_arena_release_arg(); // uint32 resulttype = 3 [json_name = "resulttype"]; void clear_resulttype(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::Node* xpr_; ::pg_query::Node* arg_; uint32_t resulttype_; uint32_t resultcollid_; int coerceformat_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class ArrayCoerceExpr final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ArrayCoerceExpr) */ { public: inline ArrayCoerceExpr() : ArrayCoerceExpr(nullptr) {} ~ArrayCoerceExpr() override; explicit PROTOBUF_CONSTEXPR ArrayCoerceExpr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ArrayCoerceExpr(const ArrayCoerceExpr& from); ArrayCoerceExpr(ArrayCoerceExpr&& from) noexcept : ArrayCoerceExpr() { *this = ::std::move(from); } inline ArrayCoerceExpr& operator=(const ArrayCoerceExpr& from) { CopyFrom(from); return *this; } inline ArrayCoerceExpr& operator=(ArrayCoerceExpr&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_ArrayCoerceExpr_default_instance_); } static constexpr int kIndexInFileMessages = 35; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ArrayCoerceExpr* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ArrayCoerceExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ArrayCoerceExpr& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ArrayCoerceExpr& from) { ArrayCoerceExpr::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ArrayCoerceExpr* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.ArrayCoerceExpr"; } protected: explicit ArrayCoerceExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_xpr() const; public: 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* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // .pg_query.Node arg = 2 [json_name = "arg"]; bool has_arg() const; private: bool _internal_has_arg() const; public: void clear_arg(); const ::pg_query::Node& arg() const; PROTOBUF_NODISCARD ::pg_query::Node* release_arg(); ::pg_query::Node* mutable_arg(); void set_allocated_arg(::pg_query::Node* arg); private: const ::pg_query::Node& _internal_arg() const; ::pg_query::Node* _internal_mutable_arg(); public: void unsafe_arena_set_allocated_arg( ::pg_query::Node* arg); ::pg_query::Node* unsafe_arena_release_arg(); // .pg_query.Node elemexpr = 3 [json_name = "elemexpr"]; bool has_elemexpr() const; private: bool _internal_has_elemexpr() const; public: void clear_elemexpr(); const ::pg_query::Node& elemexpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_elemexpr(); ::pg_query::Node* mutable_elemexpr(); void set_allocated_elemexpr(::pg_query::Node* elemexpr); private: const ::pg_query::Node& _internal_elemexpr() const; ::pg_query::Node* _internal_mutable_elemexpr(); public: void unsafe_arena_set_allocated_elemexpr( ::pg_query::Node* elemexpr); ::pg_query::Node* unsafe_arena_release_elemexpr(); // uint32 resulttype = 4 [json_name = "resulttype"]; void clear_resulttype(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::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_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class ConvertRowtypeExpr final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ConvertRowtypeExpr) */ { public: inline ConvertRowtypeExpr() : ConvertRowtypeExpr(nullptr) {} ~ConvertRowtypeExpr() override; explicit PROTOBUF_CONSTEXPR ConvertRowtypeExpr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ConvertRowtypeExpr(const ConvertRowtypeExpr& from); ConvertRowtypeExpr(ConvertRowtypeExpr&& from) noexcept : ConvertRowtypeExpr() { *this = ::std::move(from); } inline ConvertRowtypeExpr& operator=(const ConvertRowtypeExpr& from) { CopyFrom(from); return *this; } inline ConvertRowtypeExpr& operator=(ConvertRowtypeExpr&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_ConvertRowtypeExpr_default_instance_); } static constexpr int kIndexInFileMessages = 36; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ConvertRowtypeExpr* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ConvertRowtypeExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ConvertRowtypeExpr& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ConvertRowtypeExpr& from) { ConvertRowtypeExpr::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ConvertRowtypeExpr* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.ConvertRowtypeExpr"; } protected: explicit ConvertRowtypeExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_xpr() const; public: 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* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // .pg_query.Node arg = 2 [json_name = "arg"]; bool has_arg() const; private: bool _internal_has_arg() const; public: void clear_arg(); const ::pg_query::Node& arg() const; PROTOBUF_NODISCARD ::pg_query::Node* release_arg(); ::pg_query::Node* mutable_arg(); void set_allocated_arg(::pg_query::Node* arg); private: const ::pg_query::Node& _internal_arg() const; ::pg_query::Node* _internal_mutable_arg(); public: void unsafe_arena_set_allocated_arg( ::pg_query::Node* arg); ::pg_query::Node* unsafe_arena_release_arg(); // uint32 resulttype = 3 [json_name = "resulttype"]; void clear_resulttype(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::Node* xpr_; ::pg_query::Node* arg_; uint32_t resulttype_; int convertformat_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CollateExpr final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CollateExpr) */ { public: inline CollateExpr() : CollateExpr(nullptr) {} ~CollateExpr() override; explicit PROTOBUF_CONSTEXPR CollateExpr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CollateExpr(const CollateExpr& from); CollateExpr(CollateExpr&& from) noexcept : CollateExpr() { *this = ::std::move(from); } inline CollateExpr& operator=(const CollateExpr& from) { CopyFrom(from); return *this; } inline CollateExpr& operator=(CollateExpr&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CollateExpr_default_instance_); } static constexpr int kIndexInFileMessages = 37; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CollateExpr* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CollateExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CollateExpr& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CollateExpr& from) { CollateExpr::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CollateExpr* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CollateExpr"; } protected: explicit CollateExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_xpr() const; public: 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* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // .pg_query.Node arg = 2 [json_name = "arg"]; bool has_arg() const; private: bool _internal_has_arg() const; public: void clear_arg(); const ::pg_query::Node& arg() const; PROTOBUF_NODISCARD ::pg_query::Node* release_arg(); ::pg_query::Node* mutable_arg(); void set_allocated_arg(::pg_query::Node* arg); private: const ::pg_query::Node& _internal_arg() const; ::pg_query::Node* _internal_mutable_arg(); public: void unsafe_arena_set_allocated_arg( ::pg_query::Node* arg); ::pg_query::Node* unsafe_arena_release_arg(); // uint32 coll_oid = 3 [json_name = "collOid"]; void clear_coll_oid(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::Node* xpr_; ::pg_query::Node* arg_; uint32_t coll_oid_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CaseExpr final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CaseExpr) */ { public: inline CaseExpr() : CaseExpr(nullptr) {} ~CaseExpr() override; explicit PROTOBUF_CONSTEXPR CaseExpr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CaseExpr(const CaseExpr& from); CaseExpr(CaseExpr&& from) noexcept : CaseExpr() { *this = ::std::move(from); } inline CaseExpr& operator=(const CaseExpr& from) { CopyFrom(from); return *this; } inline CaseExpr& operator=(CaseExpr&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CaseExpr_default_instance_); } static constexpr int kIndexInFileMessages = 38; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CaseExpr* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CaseExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CaseExpr& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CaseExpr& from) { CaseExpr::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CaseExpr* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CaseExpr"; } protected: explicit CaseExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_args(); private: const ::pg_query::Node& _internal_args(int index) const; ::pg_query::Node* _internal_add_args(); public: const ::pg_query::Node& args(int index) const; ::pg_query::Node* add_args(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& args() const; // .pg_query.Node xpr = 1 [json_name = "xpr"]; bool has_xpr() const; private: bool _internal_has_xpr() const; public: void clear_xpr(); const ::pg_query::Node& xpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_xpr(); ::pg_query::Node* mutable_xpr(); void set_allocated_xpr(::pg_query::Node* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // .pg_query.Node arg = 4 [json_name = "arg"]; bool has_arg() const; private: bool _internal_has_arg() const; public: void clear_arg(); const ::pg_query::Node& arg() const; PROTOBUF_NODISCARD ::pg_query::Node* release_arg(); ::pg_query::Node* mutable_arg(); void set_allocated_arg(::pg_query::Node* arg); private: const ::pg_query::Node& _internal_arg() const; ::pg_query::Node* _internal_mutable_arg(); public: void unsafe_arena_set_allocated_arg( ::pg_query::Node* arg); ::pg_query::Node* unsafe_arena_release_arg(); // .pg_query.Node defresult = 6 [json_name = "defresult"]; bool has_defresult() const; private: bool _internal_has_defresult() const; public: void clear_defresult(); const ::pg_query::Node& defresult() const; PROTOBUF_NODISCARD ::pg_query::Node* release_defresult(); ::pg_query::Node* mutable_defresult(); void set_allocated_defresult(::pg_query::Node* defresult); private: const ::pg_query::Node& _internal_defresult() const; ::pg_query::Node* _internal_mutable_defresult(); public: void unsafe_arena_set_allocated_defresult( ::pg_query::Node* defresult); ::pg_query::Node* unsafe_arena_release_defresult(); // uint32 casetype = 2 [json_name = "casetype"]; void clear_casetype(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::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_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CaseWhen final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CaseWhen) */ { public: inline CaseWhen() : CaseWhen(nullptr) {} ~CaseWhen() override; explicit PROTOBUF_CONSTEXPR CaseWhen(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CaseWhen(const CaseWhen& from); CaseWhen(CaseWhen&& from) noexcept : CaseWhen() { *this = ::std::move(from); } inline CaseWhen& operator=(const CaseWhen& from) { CopyFrom(from); return *this; } inline CaseWhen& operator=(CaseWhen&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CaseWhen_default_instance_); } static constexpr int kIndexInFileMessages = 39; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CaseWhen* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CaseWhen* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CaseWhen& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CaseWhen& from) { CaseWhen::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CaseWhen* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CaseWhen"; } protected: explicit CaseWhen(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_xpr() const; public: 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* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // .pg_query.Node expr = 2 [json_name = "expr"]; bool has_expr() const; private: bool _internal_has_expr() const; public: void clear_expr(); const ::pg_query::Node& expr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_expr(); ::pg_query::Node* mutable_expr(); void set_allocated_expr(::pg_query::Node* expr); private: const ::pg_query::Node& _internal_expr() const; ::pg_query::Node* _internal_mutable_expr(); public: void unsafe_arena_set_allocated_expr( ::pg_query::Node* expr); ::pg_query::Node* unsafe_arena_release_expr(); // .pg_query.Node result = 3 [json_name = "result"]; bool has_result() const; private: bool _internal_has_result() const; public: void clear_result(); const ::pg_query::Node& result() const; PROTOBUF_NODISCARD ::pg_query::Node* release_result(); ::pg_query::Node* mutable_result(); void set_allocated_result(::pg_query::Node* result); private: const ::pg_query::Node& _internal_result() const; ::pg_query::Node* _internal_mutable_result(); public: void unsafe_arena_set_allocated_result( ::pg_query::Node* result); ::pg_query::Node* unsafe_arena_release_result(); // int32 location = 4 [json_name = "location"]; void clear_location(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::Node* xpr_; ::pg_query::Node* expr_; ::pg_query::Node* result_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CaseTestExpr final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CaseTestExpr) */ { public: inline CaseTestExpr() : CaseTestExpr(nullptr) {} ~CaseTestExpr() override; explicit PROTOBUF_CONSTEXPR CaseTestExpr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CaseTestExpr(const CaseTestExpr& from); CaseTestExpr(CaseTestExpr&& from) noexcept : CaseTestExpr() { *this = ::std::move(from); } inline CaseTestExpr& operator=(const CaseTestExpr& from) { CopyFrom(from); return *this; } inline CaseTestExpr& operator=(CaseTestExpr&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CaseTestExpr_default_instance_); } static constexpr int kIndexInFileMessages = 40; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CaseTestExpr* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CaseTestExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CaseTestExpr& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CaseTestExpr& from) { CaseTestExpr::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CaseTestExpr* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CaseTestExpr"; } protected: explicit CaseTestExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_xpr() const; public: 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* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // uint32 type_id = 2 [json_name = "typeId"]; void clear_type_id(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::Node* xpr_; uint32_t type_id_; int32_t type_mod_; uint32_t collation_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class ArrayExpr final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ArrayExpr) */ { public: inline ArrayExpr() : ArrayExpr(nullptr) {} ~ArrayExpr() override; explicit PROTOBUF_CONSTEXPR ArrayExpr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ArrayExpr(const ArrayExpr& from); ArrayExpr(ArrayExpr&& from) noexcept : ArrayExpr() { *this = ::std::move(from); } inline ArrayExpr& operator=(const ArrayExpr& from) { CopyFrom(from); return *this; } inline ArrayExpr& operator=(ArrayExpr&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_ArrayExpr_default_instance_); } static constexpr int kIndexInFileMessages = 41; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ArrayExpr* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ArrayExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ArrayExpr& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ArrayExpr& from) { ArrayExpr::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ArrayExpr* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.ArrayExpr"; } protected: explicit ArrayExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_elements(); private: const ::pg_query::Node& _internal_elements(int index) const; ::pg_query::Node* _internal_add_elements(); public: const ::pg_query::Node& elements(int index) const; ::pg_query::Node* add_elements(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& elements() const; // .pg_query.Node xpr = 1 [json_name = "xpr"]; bool has_xpr() const; private: bool _internal_has_xpr() const; public: void clear_xpr(); const ::pg_query::Node& xpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_xpr(); ::pg_query::Node* mutable_xpr(); void set_allocated_xpr(::pg_query::Node* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // uint32 array_typeid = 2 [json_name = "array_typeid"]; void clear_array_typeid(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::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_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class RowExpr final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RowExpr) */ { public: inline RowExpr() : RowExpr(nullptr) {} ~RowExpr() override; explicit PROTOBUF_CONSTEXPR RowExpr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); RowExpr(const RowExpr& from); RowExpr(RowExpr&& from) noexcept : RowExpr() { *this = ::std::move(from); } inline RowExpr& operator=(const RowExpr& from) { CopyFrom(from); return *this; } inline RowExpr& operator=(RowExpr&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_RowExpr_default_instance_); } static constexpr int kIndexInFileMessages = 42; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(RowExpr* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- RowExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const RowExpr& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const RowExpr& from) { RowExpr::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(RowExpr* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.RowExpr"; } protected: explicit RowExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_args(); private: const ::pg_query::Node& _internal_args(int index) const; ::pg_query::Node* _internal_add_args(); public: const ::pg_query::Node& args(int index) const; ::pg_query::Node* add_args(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& args() const; // repeated .pg_query.Node colnames = 5 [json_name = "colnames"]; int colnames_size() const; private: int _internal_colnames_size() const; public: void clear_colnames(); ::pg_query::Node* mutable_colnames(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_colnames(); private: const ::pg_query::Node& _internal_colnames(int index) const; ::pg_query::Node* _internal_add_colnames(); public: const ::pg_query::Node& colnames(int index) const; ::pg_query::Node* add_colnames(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& colnames() const; // .pg_query.Node xpr = 1 [json_name = "xpr"]; bool has_xpr() const; private: bool _internal_has_xpr() const; public: void clear_xpr(); const ::pg_query::Node& xpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_xpr(); ::pg_query::Node* mutable_xpr(); void set_allocated_xpr(::pg_query::Node* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // uint32 row_typeid = 3 [json_name = "row_typeid"]; void clear_row_typeid(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > colnames_; ::pg_query::Node* xpr_; uint32_t row_typeid_; int row_format_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class RowCompareExpr final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RowCompareExpr) */ { public: inline RowCompareExpr() : RowCompareExpr(nullptr) {} ~RowCompareExpr() override; explicit PROTOBUF_CONSTEXPR RowCompareExpr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); RowCompareExpr(const RowCompareExpr& from); RowCompareExpr(RowCompareExpr&& from) noexcept : RowCompareExpr() { *this = ::std::move(from); } inline RowCompareExpr& operator=(const RowCompareExpr& from) { CopyFrom(from); return *this; } inline RowCompareExpr& operator=(RowCompareExpr&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_RowCompareExpr_default_instance_); } static constexpr int kIndexInFileMessages = 43; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(RowCompareExpr* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- RowCompareExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const RowCompareExpr& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const RowCompareExpr& from) { RowCompareExpr::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(RowCompareExpr* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.RowCompareExpr"; } protected: explicit RowCompareExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_opnos(); private: const ::pg_query::Node& _internal_opnos(int index) const; ::pg_query::Node* _internal_add_opnos(); public: const ::pg_query::Node& opnos(int index) const; ::pg_query::Node* add_opnos(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& opnos() const; // repeated .pg_query.Node opfamilies = 4 [json_name = "opfamilies"]; int opfamilies_size() const; private: int _internal_opfamilies_size() const; public: void clear_opfamilies(); ::pg_query::Node* mutable_opfamilies(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_opfamilies(); private: const ::pg_query::Node& _internal_opfamilies(int index) const; ::pg_query::Node* _internal_add_opfamilies(); public: const ::pg_query::Node& opfamilies(int index) const; ::pg_query::Node* add_opfamilies(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& opfamilies() const; // repeated .pg_query.Node inputcollids = 5 [json_name = "inputcollids"]; int inputcollids_size() const; private: int _internal_inputcollids_size() const; public: void clear_inputcollids(); ::pg_query::Node* mutable_inputcollids(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_inputcollids(); private: const ::pg_query::Node& _internal_inputcollids(int index) const; ::pg_query::Node* _internal_add_inputcollids(); public: const ::pg_query::Node& inputcollids(int index) const; ::pg_query::Node* add_inputcollids(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& inputcollids() const; // repeated .pg_query.Node largs = 6 [json_name = "largs"]; int largs_size() const; private: int _internal_largs_size() const; public: void clear_largs(); ::pg_query::Node* mutable_largs(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_largs(); private: const ::pg_query::Node& _internal_largs(int index) const; ::pg_query::Node* _internal_add_largs(); public: const ::pg_query::Node& largs(int index) const; ::pg_query::Node* add_largs(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& largs() const; // repeated .pg_query.Node rargs = 7 [json_name = "rargs"]; int rargs_size() const; private: int _internal_rargs_size() const; public: void clear_rargs(); ::pg_query::Node* mutable_rargs(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_rargs(); private: const ::pg_query::Node& _internal_rargs(int index) const; ::pg_query::Node* _internal_add_rargs(); public: const ::pg_query::Node& rargs(int index) const; ::pg_query::Node* add_rargs(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& rargs() const; // .pg_query.Node xpr = 1 [json_name = "xpr"]; bool has_xpr() const; private: bool _internal_has_xpr() const; public: void clear_xpr(); const ::pg_query::Node& xpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_xpr(); ::pg_query::Node* mutable_xpr(); void set_allocated_xpr(::pg_query::Node* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // .pg_query.RowCompareType rctype = 2 [json_name = "rctype"]; void clear_rctype(); ::pg_query::RowCompareType rctype() const; void set_rctype(::pg_query::RowCompareType value); private: ::pg_query::RowCompareType _internal_rctype() const; void _internal_set_rctype(::pg_query::RowCompareType value); public: // @@protoc_insertion_point(class_scope:pg_query.RowCompareExpr) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > opnos_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > opfamilies_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > inputcollids_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > largs_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > rargs_; ::pg_query::Node* xpr_; int rctype_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CoalesceExpr final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CoalesceExpr) */ { public: inline CoalesceExpr() : CoalesceExpr(nullptr) {} ~CoalesceExpr() override; explicit PROTOBUF_CONSTEXPR CoalesceExpr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CoalesceExpr(const CoalesceExpr& from); CoalesceExpr(CoalesceExpr&& from) noexcept : CoalesceExpr() { *this = ::std::move(from); } inline CoalesceExpr& operator=(const CoalesceExpr& from) { CopyFrom(from); return *this; } inline CoalesceExpr& operator=(CoalesceExpr&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CoalesceExpr_default_instance_); } static constexpr int kIndexInFileMessages = 44; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CoalesceExpr* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CoalesceExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CoalesceExpr& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CoalesceExpr& from) { CoalesceExpr::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CoalesceExpr* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CoalesceExpr"; } protected: explicit CoalesceExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_args(); private: const ::pg_query::Node& _internal_args(int index) const; ::pg_query::Node* _internal_add_args(); public: const ::pg_query::Node& args(int index) const; ::pg_query::Node* add_args(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& args() const; // .pg_query.Node xpr = 1 [json_name = "xpr"]; bool has_xpr() const; private: bool _internal_has_xpr() const; public: void clear_xpr(); const ::pg_query::Node& xpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_xpr(); ::pg_query::Node* mutable_xpr(); void set_allocated_xpr(::pg_query::Node* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // uint32 coalescetype = 2 [json_name = "coalescetype"]; void clear_coalescetype(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_; ::pg_query::Node* xpr_; uint32_t coalescetype_; uint32_t coalescecollid_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class MinMaxExpr final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.MinMaxExpr) */ { public: inline MinMaxExpr() : MinMaxExpr(nullptr) {} ~MinMaxExpr() override; explicit PROTOBUF_CONSTEXPR MinMaxExpr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); MinMaxExpr(const MinMaxExpr& from); MinMaxExpr(MinMaxExpr&& from) noexcept : MinMaxExpr() { *this = ::std::move(from); } inline MinMaxExpr& operator=(const MinMaxExpr& from) { CopyFrom(from); return *this; } inline MinMaxExpr& operator=(MinMaxExpr&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_MinMaxExpr_default_instance_); } static constexpr int kIndexInFileMessages = 45; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(MinMaxExpr* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- MinMaxExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const MinMaxExpr& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const MinMaxExpr& from) { MinMaxExpr::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(MinMaxExpr* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.MinMaxExpr"; } protected: explicit MinMaxExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_args(); private: const ::pg_query::Node& _internal_args(int index) const; ::pg_query::Node* _internal_add_args(); public: const ::pg_query::Node& args(int index) const; ::pg_query::Node* add_args(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& args() const; // .pg_query.Node xpr = 1 [json_name = "xpr"]; bool has_xpr() const; private: bool _internal_has_xpr() const; public: void clear_xpr(); const ::pg_query::Node& xpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_xpr(); ::pg_query::Node* mutable_xpr(); void set_allocated_xpr(::pg_query::Node* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // uint32 minmaxtype = 2 [json_name = "minmaxtype"]; void clear_minmaxtype(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_; ::pg_query::Node* xpr_; uint32_t minmaxtype_; uint32_t minmaxcollid_; uint32_t inputcollid_; int op_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class SQLValueFunction final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.SQLValueFunction) */ { public: inline SQLValueFunction() : SQLValueFunction(nullptr) {} ~SQLValueFunction() override; explicit PROTOBUF_CONSTEXPR SQLValueFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); SQLValueFunction(const SQLValueFunction& from); SQLValueFunction(SQLValueFunction&& from) noexcept : SQLValueFunction() { *this = ::std::move(from); } inline SQLValueFunction& operator=(const SQLValueFunction& from) { CopyFrom(from); return *this; } inline SQLValueFunction& operator=(SQLValueFunction&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_SQLValueFunction_default_instance_); } static constexpr int kIndexInFileMessages = 46; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SQLValueFunction* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- SQLValueFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const SQLValueFunction& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const SQLValueFunction& from) { SQLValueFunction::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(SQLValueFunction* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.SQLValueFunction"; } protected: explicit SQLValueFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_xpr() const; public: 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* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // .pg_query.SQLValueFunctionOp op = 2 [json_name = "op"]; void clear_op(); ::pg_query::SQLValueFunctionOp op() const; void set_op(::pg_query::SQLValueFunctionOp value); private: ::pg_query::SQLValueFunctionOp _internal_op() const; void _internal_set_op(::pg_query::SQLValueFunctionOp value); public: // uint32 type = 3 [json_name = "type"]; void clear_type(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::Node* xpr_; int op_; uint32_t type_; int32_t typmod_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class XmlExpr final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.XmlExpr) */ { public: inline XmlExpr() : XmlExpr(nullptr) {} ~XmlExpr() override; explicit PROTOBUF_CONSTEXPR XmlExpr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); XmlExpr(const XmlExpr& from); XmlExpr(XmlExpr&& from) noexcept : XmlExpr() { *this = ::std::move(from); } inline XmlExpr& operator=(const XmlExpr& from) { CopyFrom(from); return *this; } inline XmlExpr& operator=(XmlExpr&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_XmlExpr_default_instance_); } static constexpr int kIndexInFileMessages = 47; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(XmlExpr* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- XmlExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const XmlExpr& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const XmlExpr& from) { XmlExpr::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(XmlExpr* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.XmlExpr"; } protected: explicit XmlExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kNamedArgsFieldNumber = 4, kArgNamesFieldNumber = 5, kArgsFieldNumber = 6, kNameFieldNumber = 3, kXprFieldNumber = 1, kOpFieldNumber = 2, kXmloptionFieldNumber = 7, kTypeFieldNumber = 8, kTypmodFieldNumber = 9, kLocationFieldNumber = 10, }; // repeated .pg_query.Node named_args = 4 [json_name = "named_args"]; int named_args_size() const; private: int _internal_named_args_size() const; public: void clear_named_args(); ::pg_query::Node* mutable_named_args(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_named_args(); private: const ::pg_query::Node& _internal_named_args(int index) const; ::pg_query::Node* _internal_add_named_args(); public: const ::pg_query::Node& named_args(int index) const; ::pg_query::Node* add_named_args(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& named_args() const; // repeated .pg_query.Node arg_names = 5 [json_name = "arg_names"]; int arg_names_size() const; private: int _internal_arg_names_size() const; public: void clear_arg_names(); ::pg_query::Node* mutable_arg_names(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_arg_names(); private: const ::pg_query::Node& _internal_arg_names(int index) const; ::pg_query::Node* _internal_add_arg_names(); public: const ::pg_query::Node& arg_names(int index) const; ::pg_query::Node* add_arg_names(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& arg_names() const; // repeated .pg_query.Node args = 6 [json_name = "args"]; int args_size() const; private: int _internal_args_size() const; public: void clear_args(); ::pg_query::Node* mutable_args(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_args(); private: const ::pg_query::Node& _internal_args(int index) const; ::pg_query::Node* _internal_add_args(); public: const ::pg_query::Node& args(int index) const; ::pg_query::Node* add_args(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& args() const; // string name = 3 [json_name = "name"]; void clear_name(); const std::string& name() const; template void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); 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; private: bool _internal_has_xpr() const; public: 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* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // .pg_query.XmlExprOp op = 2 [json_name = "op"]; void clear_op(); ::pg_query::XmlExprOp op() const; void set_op(::pg_query::XmlExprOp value); private: ::pg_query::XmlExprOp _internal_op() const; void _internal_set_op(::pg_query::XmlExprOp value); public: // .pg_query.XmlOptionType xmloption = 7 [json_name = "xmloption"]; void clear_xmloption(); ::pg_query::XmlOptionType xmloption() const; void set_xmloption(::pg_query::XmlOptionType value); private: ::pg_query::XmlOptionType _internal_xmloption() const; void _internal_set_xmloption(::pg_query::XmlOptionType value); public: // uint32 type = 8 [json_name = "type"]; void clear_type(); 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 = 9 [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 = 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.XmlExpr) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > named_args_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > arg_names_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; ::pg_query::Node* xpr_; int op_; int xmloption_; uint32_t type_; int32_t typmod_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class NullTest final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.NullTest) */ { public: inline NullTest() : NullTest(nullptr) {} ~NullTest() override; explicit PROTOBUF_CONSTEXPR NullTest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); NullTest(const NullTest& from); NullTest(NullTest&& from) noexcept : NullTest() { *this = ::std::move(from); } inline NullTest& operator=(const NullTest& from) { CopyFrom(from); return *this; } inline NullTest& operator=(NullTest&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_NullTest_default_instance_); } static constexpr int kIndexInFileMessages = 48; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(NullTest* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- NullTest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const NullTest& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const NullTest& from) { NullTest::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(NullTest* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.NullTest"; } protected: explicit NullTest(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_xpr() const; public: 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* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // .pg_query.Node arg = 2 [json_name = "arg"]; bool has_arg() const; private: bool _internal_has_arg() const; public: void clear_arg(); const ::pg_query::Node& arg() const; PROTOBUF_NODISCARD ::pg_query::Node* release_arg(); ::pg_query::Node* mutable_arg(); void set_allocated_arg(::pg_query::Node* arg); private: const ::pg_query::Node& _internal_arg() const; ::pg_query::Node* _internal_mutable_arg(); public: void unsafe_arena_set_allocated_arg( ::pg_query::Node* arg); ::pg_query::Node* unsafe_arena_release_arg(); // .pg_query.NullTestType nulltesttype = 3 [json_name = "nulltesttype"]; void clear_nulltesttype(); ::pg_query::NullTestType nulltesttype() const; void set_nulltesttype(::pg_query::NullTestType value); private: ::pg_query::NullTestType _internal_nulltesttype() const; void _internal_set_nulltesttype(::pg_query::NullTestType value); public: // bool argisrow = 4 [json_name = "argisrow"]; void clear_argisrow(); bool argisrow() const; void set_argisrow(bool value); private: bool _internal_argisrow() const; void _internal_set_argisrow(bool value); public: // int32 location = 5 [json_name = "location"]; void clear_location(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::Node* xpr_; ::pg_query::Node* arg_; int nulltesttype_; bool argisrow_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class BooleanTest final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.BooleanTest) */ { public: inline BooleanTest() : BooleanTest(nullptr) {} ~BooleanTest() override; explicit PROTOBUF_CONSTEXPR BooleanTest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); BooleanTest(const BooleanTest& from); BooleanTest(BooleanTest&& from) noexcept : BooleanTest() { *this = ::std::move(from); } inline BooleanTest& operator=(const BooleanTest& from) { CopyFrom(from); return *this; } inline BooleanTest& operator=(BooleanTest&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_BooleanTest_default_instance_); } static constexpr int kIndexInFileMessages = 49; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(BooleanTest* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- BooleanTest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const BooleanTest& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const BooleanTest& from) { BooleanTest::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(BooleanTest* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.BooleanTest"; } protected: explicit BooleanTest(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_xpr() const; public: 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* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // .pg_query.Node arg = 2 [json_name = "arg"]; bool has_arg() const; private: bool _internal_has_arg() const; public: void clear_arg(); const ::pg_query::Node& arg() const; PROTOBUF_NODISCARD ::pg_query::Node* release_arg(); ::pg_query::Node* mutable_arg(); void set_allocated_arg(::pg_query::Node* arg); private: const ::pg_query::Node& _internal_arg() const; ::pg_query::Node* _internal_mutable_arg(); public: void unsafe_arena_set_allocated_arg( ::pg_query::Node* arg); ::pg_query::Node* unsafe_arena_release_arg(); // .pg_query.BoolTestType booltesttype = 3 [json_name = "booltesttype"]; void clear_booltesttype(); ::pg_query::BoolTestType booltesttype() const; void set_booltesttype(::pg_query::BoolTestType value); private: ::pg_query::BoolTestType _internal_booltesttype() const; void _internal_set_booltesttype(::pg_query::BoolTestType value); public: // int32 location = 4 [json_name = "location"]; void clear_location(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::Node* xpr_; ::pg_query::Node* arg_; int booltesttype_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CoerceToDomain final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CoerceToDomain) */ { public: inline CoerceToDomain() : CoerceToDomain(nullptr) {} ~CoerceToDomain() override; explicit PROTOBUF_CONSTEXPR CoerceToDomain(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CoerceToDomain(const CoerceToDomain& from); CoerceToDomain(CoerceToDomain&& from) noexcept : CoerceToDomain() { *this = ::std::move(from); } inline CoerceToDomain& operator=(const CoerceToDomain& from) { CopyFrom(from); return *this; } inline CoerceToDomain& operator=(CoerceToDomain&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CoerceToDomain_default_instance_); } static constexpr int kIndexInFileMessages = 50; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CoerceToDomain* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CoerceToDomain* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CoerceToDomain& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CoerceToDomain& from) { CoerceToDomain::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CoerceToDomain* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CoerceToDomain"; } protected: explicit CoerceToDomain(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_xpr() const; public: 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* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // .pg_query.Node arg = 2 [json_name = "arg"]; bool has_arg() const; private: bool _internal_has_arg() const; public: void clear_arg(); const ::pg_query::Node& arg() const; PROTOBUF_NODISCARD ::pg_query::Node* release_arg(); ::pg_query::Node* mutable_arg(); void set_allocated_arg(::pg_query::Node* arg); private: const ::pg_query::Node& _internal_arg() const; ::pg_query::Node* _internal_mutable_arg(); public: void unsafe_arena_set_allocated_arg( ::pg_query::Node* arg); ::pg_query::Node* unsafe_arena_release_arg(); // uint32 resulttype = 3 [json_name = "resulttype"]; void clear_resulttype(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::Node* xpr_; ::pg_query::Node* arg_; uint32_t resulttype_; int32_t resulttypmod_; uint32_t resultcollid_; int coercionformat_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CoerceToDomainValue final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CoerceToDomainValue) */ { public: inline CoerceToDomainValue() : CoerceToDomainValue(nullptr) {} ~CoerceToDomainValue() override; explicit PROTOBUF_CONSTEXPR CoerceToDomainValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CoerceToDomainValue(const CoerceToDomainValue& from); CoerceToDomainValue(CoerceToDomainValue&& from) noexcept : CoerceToDomainValue() { *this = ::std::move(from); } inline CoerceToDomainValue& operator=(const CoerceToDomainValue& from) { CopyFrom(from); return *this; } inline CoerceToDomainValue& operator=(CoerceToDomainValue&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CoerceToDomainValue_default_instance_); } static constexpr int kIndexInFileMessages = 51; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CoerceToDomainValue* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CoerceToDomainValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CoerceToDomainValue& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CoerceToDomainValue& from) { CoerceToDomainValue::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CoerceToDomainValue* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CoerceToDomainValue"; } protected: explicit CoerceToDomainValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_xpr() const; public: 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* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // uint32 type_id = 2 [json_name = "typeId"]; void clear_type_id(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::Node* xpr_; uint32_t type_id_; int32_t type_mod_; uint32_t collation_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class SetToDefault final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.SetToDefault) */ { public: inline SetToDefault() : SetToDefault(nullptr) {} ~SetToDefault() override; explicit PROTOBUF_CONSTEXPR SetToDefault(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); SetToDefault(const SetToDefault& from); SetToDefault(SetToDefault&& from) noexcept : SetToDefault() { *this = ::std::move(from); } inline SetToDefault& operator=(const SetToDefault& from) { CopyFrom(from); return *this; } inline SetToDefault& operator=(SetToDefault&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_SetToDefault_default_instance_); } static constexpr int kIndexInFileMessages = 52; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SetToDefault* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- SetToDefault* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const SetToDefault& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const SetToDefault& from) { SetToDefault::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(SetToDefault* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.SetToDefault"; } protected: explicit SetToDefault(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_xpr() const; public: 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* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // uint32 type_id = 2 [json_name = "typeId"]; void clear_type_id(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::Node* xpr_; uint32_t type_id_; int32_t type_mod_; uint32_t collation_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CurrentOfExpr final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CurrentOfExpr) */ { public: inline CurrentOfExpr() : CurrentOfExpr(nullptr) {} ~CurrentOfExpr() override; explicit PROTOBUF_CONSTEXPR CurrentOfExpr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CurrentOfExpr(const CurrentOfExpr& from); CurrentOfExpr(CurrentOfExpr&& from) noexcept : CurrentOfExpr() { *this = ::std::move(from); } inline CurrentOfExpr& operator=(const CurrentOfExpr& from) { CopyFrom(from); return *this; } inline CurrentOfExpr& operator=(CurrentOfExpr&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CurrentOfExpr_default_instance_); } static constexpr int kIndexInFileMessages = 53; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CurrentOfExpr* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CurrentOfExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CurrentOfExpr& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CurrentOfExpr& from) { CurrentOfExpr::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CurrentOfExpr* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CurrentOfExpr"; } protected: explicit CurrentOfExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_cursor_name(ArgT0&& arg0, ArgT... args); std::string* mutable_cursor_name(); PROTOBUF_NODISCARD std::string* release_cursor_name(); void set_allocated_cursor_name(std::string* cursor_name); 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; private: bool _internal_has_xpr() const; public: 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* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // uint32 cvarno = 2 [json_name = "cvarno"]; void clear_cvarno(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cursor_name_; ::pg_query::Node* xpr_; uint32_t cvarno_; int32_t cursor_param_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class NextValueExpr final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.NextValueExpr) */ { public: inline NextValueExpr() : NextValueExpr(nullptr) {} ~NextValueExpr() override; explicit PROTOBUF_CONSTEXPR NextValueExpr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); NextValueExpr(const NextValueExpr& from); NextValueExpr(NextValueExpr&& from) noexcept : NextValueExpr() { *this = ::std::move(from); } inline NextValueExpr& operator=(const NextValueExpr& from) { CopyFrom(from); return *this; } inline NextValueExpr& operator=(NextValueExpr&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_NextValueExpr_default_instance_); } static constexpr int kIndexInFileMessages = 54; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(NextValueExpr* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- NextValueExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const NextValueExpr& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const NextValueExpr& from) { NextValueExpr::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(NextValueExpr* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.NextValueExpr"; } protected: explicit NextValueExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_xpr() const; public: 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* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // uint32 seqid = 2 [json_name = "seqid"]; void clear_seqid(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::Node* xpr_; uint32_t seqid_; uint32_t type_id_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class InferenceElem final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.InferenceElem) */ { public: inline InferenceElem() : InferenceElem(nullptr) {} ~InferenceElem() override; explicit PROTOBUF_CONSTEXPR InferenceElem(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); InferenceElem(const InferenceElem& from); InferenceElem(InferenceElem&& from) noexcept : InferenceElem() { *this = ::std::move(from); } inline InferenceElem& operator=(const InferenceElem& from) { CopyFrom(from); return *this; } inline InferenceElem& operator=(InferenceElem&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_InferenceElem_default_instance_); } static constexpr int kIndexInFileMessages = 55; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(InferenceElem* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- InferenceElem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const InferenceElem& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const InferenceElem& from) { InferenceElem::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(InferenceElem* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.InferenceElem"; } protected: explicit InferenceElem(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_xpr() const; public: 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* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // .pg_query.Node expr = 2 [json_name = "expr"]; bool has_expr() const; private: bool _internal_has_expr() const; public: void clear_expr(); const ::pg_query::Node& expr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_expr(); ::pg_query::Node* mutable_expr(); void set_allocated_expr(::pg_query::Node* expr); private: const ::pg_query::Node& _internal_expr() const; ::pg_query::Node* _internal_mutable_expr(); public: void unsafe_arena_set_allocated_expr( ::pg_query::Node* expr); ::pg_query::Node* unsafe_arena_release_expr(); // uint32 infercollid = 3 [json_name = "infercollid"]; void clear_infercollid(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::Node* xpr_; ::pg_query::Node* expr_; uint32_t infercollid_; uint32_t inferopclass_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class TargetEntry final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.TargetEntry) */ { public: inline TargetEntry() : TargetEntry(nullptr) {} ~TargetEntry() override; explicit PROTOBUF_CONSTEXPR TargetEntry(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); TargetEntry(const TargetEntry& from); TargetEntry(TargetEntry&& from) noexcept : TargetEntry() { *this = ::std::move(from); } inline TargetEntry& operator=(const TargetEntry& from) { CopyFrom(from); return *this; } inline TargetEntry& operator=(TargetEntry&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_TargetEntry_default_instance_); } static constexpr int kIndexInFileMessages = 56; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(TargetEntry* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- TargetEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const TargetEntry& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const TargetEntry& from) { TargetEntry::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(TargetEntry* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.TargetEntry"; } protected: explicit TargetEntry(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_resname(ArgT0&& arg0, ArgT... args); std::string* mutable_resname(); PROTOBUF_NODISCARD std::string* release_resname(); void set_allocated_resname(std::string* resname); 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; private: bool _internal_has_xpr() const; public: 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* xpr); private: const ::pg_query::Node& _internal_xpr() const; ::pg_query::Node* _internal_mutable_xpr(); public: void unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr); ::pg_query::Node* unsafe_arena_release_xpr(); // .pg_query.Node expr = 2 [json_name = "expr"]; bool has_expr() const; private: bool _internal_has_expr() const; public: void clear_expr(); const ::pg_query::Node& expr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_expr(); ::pg_query::Node* mutable_expr(); void set_allocated_expr(::pg_query::Node* expr); private: const ::pg_query::Node& _internal_expr() const; ::pg_query::Node* _internal_mutable_expr(); public: void unsafe_arena_set_allocated_expr( ::pg_query::Node* expr); ::pg_query::Node* unsafe_arena_release_expr(); // int32 resno = 3 [json_name = "resno"]; void clear_resno(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::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_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class RangeTblRef final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RangeTblRef) */ { public: inline RangeTblRef() : RangeTblRef(nullptr) {} ~RangeTblRef() override; explicit PROTOBUF_CONSTEXPR RangeTblRef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); RangeTblRef(const RangeTblRef& from); RangeTblRef(RangeTblRef&& from) noexcept : RangeTblRef() { *this = ::std::move(from); } inline RangeTblRef& operator=(const RangeTblRef& from) { CopyFrom(from); return *this; } inline RangeTblRef& operator=(RangeTblRef&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_RangeTblRef_default_instance_); } static constexpr int kIndexInFileMessages = 57; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(RangeTblRef* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- RangeTblRef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const RangeTblRef& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const RangeTblRef& from) { RangeTblRef::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(RangeTblRef* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.RangeTblRef"; } protected: explicit RangeTblRef(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { int32_t rtindex_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class JoinExpr final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.JoinExpr) */ { public: inline JoinExpr() : JoinExpr(nullptr) {} ~JoinExpr() override; explicit PROTOBUF_CONSTEXPR JoinExpr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); JoinExpr(const JoinExpr& from); JoinExpr(JoinExpr&& from) noexcept : JoinExpr() { *this = ::std::move(from); } inline JoinExpr& operator=(const JoinExpr& from) { CopyFrom(from); return *this; } inline JoinExpr& operator=(JoinExpr&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_JoinExpr_default_instance_); } static constexpr int kIndexInFileMessages = 58; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(JoinExpr* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- JoinExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const JoinExpr& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const JoinExpr& from) { JoinExpr::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(JoinExpr* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.JoinExpr"; } protected: explicit JoinExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_using_clause(); private: const ::pg_query::Node& _internal_using_clause(int index) const; ::pg_query::Node* _internal_add_using_clause(); public: const ::pg_query::Node& using_clause(int index) const; ::pg_query::Node* add_using_clause(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& using_clause() const; // .pg_query.Node larg = 3 [json_name = "larg"]; bool has_larg() const; private: bool _internal_has_larg() const; public: void clear_larg(); const ::pg_query::Node& larg() const; PROTOBUF_NODISCARD ::pg_query::Node* release_larg(); ::pg_query::Node* mutable_larg(); void set_allocated_larg(::pg_query::Node* larg); private: const ::pg_query::Node& _internal_larg() const; ::pg_query::Node* _internal_mutable_larg(); public: void unsafe_arena_set_allocated_larg( ::pg_query::Node* larg); ::pg_query::Node* unsafe_arena_release_larg(); // .pg_query.Node rarg = 4 [json_name = "rarg"]; bool has_rarg() const; private: bool _internal_has_rarg() const; public: void clear_rarg(); const ::pg_query::Node& rarg() const; PROTOBUF_NODISCARD ::pg_query::Node* release_rarg(); ::pg_query::Node* mutable_rarg(); void set_allocated_rarg(::pg_query::Node* rarg); private: const ::pg_query::Node& _internal_rarg() const; ::pg_query::Node* _internal_mutable_rarg(); public: void unsafe_arena_set_allocated_rarg( ::pg_query::Node* rarg); ::pg_query::Node* unsafe_arena_release_rarg(); // .pg_query.Alias join_using_alias = 6 [json_name = "join_using_alias"]; bool has_join_using_alias() const; private: bool _internal_has_join_using_alias() const; public: 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* join_using_alias); private: const ::pg_query::Alias& _internal_join_using_alias() const; ::pg_query::Alias* _internal_mutable_join_using_alias(); public: void unsafe_arena_set_allocated_join_using_alias( ::pg_query::Alias* join_using_alias); ::pg_query::Alias* unsafe_arena_release_join_using_alias(); // .pg_query.Node quals = 7 [json_name = "quals"]; bool has_quals() const; private: bool _internal_has_quals() const; public: 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* quals); private: const ::pg_query::Node& _internal_quals() const; ::pg_query::Node* _internal_mutable_quals(); public: void unsafe_arena_set_allocated_quals( ::pg_query::Node* quals); ::pg_query::Node* unsafe_arena_release_quals(); // .pg_query.Alias alias = 8 [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* alias); private: const ::pg_query::Alias& _internal_alias() const; ::pg_query::Alias* _internal_mutable_alias(); public: void unsafe_arena_set_allocated_alias( ::pg_query::Alias* alias); ::pg_query::Alias* unsafe_arena_release_alias(); // .pg_query.JoinType jointype = 1 [json_name = "jointype"]; void clear_jointype(); ::pg_query::JoinType jointype() const; void set_jointype(::pg_query::JoinType value); private: ::pg_query::JoinType _internal_jointype() const; void _internal_set_jointype(::pg_query::JoinType value); public: // bool is_natural = 2 [json_name = "isNatural"]; void clear_is_natural(); bool is_natural() const; void set_is_natural(bool value); private: bool _internal_is_natural() const; void _internal_set_is_natural(bool value); public: // int32 rtindex = 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::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_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class FromExpr final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.FromExpr) */ { public: inline FromExpr() : FromExpr(nullptr) {} ~FromExpr() override; explicit PROTOBUF_CONSTEXPR FromExpr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); FromExpr(const FromExpr& from); FromExpr(FromExpr&& from) noexcept : FromExpr() { *this = ::std::move(from); } inline FromExpr& operator=(const FromExpr& from) { CopyFrom(from); return *this; } inline FromExpr& operator=(FromExpr&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_FromExpr_default_instance_); } static constexpr int kIndexInFileMessages = 59; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(FromExpr* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- FromExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const FromExpr& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const FromExpr& from) { FromExpr::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(FromExpr* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.FromExpr"; } protected: explicit FromExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_fromlist(); private: const ::pg_query::Node& _internal_fromlist(int index) const; ::pg_query::Node* _internal_add_fromlist(); public: const ::pg_query::Node& fromlist(int index) const; ::pg_query::Node* add_fromlist(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& fromlist() const; // .pg_query.Node quals = 2 [json_name = "quals"]; bool has_quals() const; private: bool _internal_has_quals() const; public: void clear_quals(); const ::pg_query::Node& quals() const; PROTOBUF_NODISCARD ::pg_query::Node* release_quals(); ::pg_query::Node* mutable_quals(); void set_allocated_quals(::pg_query::Node* quals); private: const ::pg_query::Node& _internal_quals() const; ::pg_query::Node* _internal_mutable_quals(); public: void unsafe_arena_set_allocated_quals( ::pg_query::Node* quals); ::pg_query::Node* unsafe_arena_release_quals(); // @@protoc_insertion_point(class_scope:pg_query.FromExpr) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > fromlist_; ::pg_query::Node* quals_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class OnConflictExpr final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.OnConflictExpr) */ { public: inline OnConflictExpr() : OnConflictExpr(nullptr) {} ~OnConflictExpr() override; explicit PROTOBUF_CONSTEXPR OnConflictExpr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); OnConflictExpr(const OnConflictExpr& from); OnConflictExpr(OnConflictExpr&& from) noexcept : OnConflictExpr() { *this = ::std::move(from); } inline OnConflictExpr& operator=(const OnConflictExpr& from) { CopyFrom(from); return *this; } inline OnConflictExpr& operator=(OnConflictExpr&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_OnConflictExpr_default_instance_); } static constexpr int kIndexInFileMessages = 60; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(OnConflictExpr* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- OnConflictExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const OnConflictExpr& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const OnConflictExpr& from) { OnConflictExpr::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(OnConflictExpr* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.OnConflictExpr"; } protected: explicit OnConflictExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_arbiter_elems(); private: const ::pg_query::Node& _internal_arbiter_elems(int index) const; ::pg_query::Node* _internal_add_arbiter_elems(); public: const ::pg_query::Node& arbiter_elems(int index) const; ::pg_query::Node* add_arbiter_elems(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& arbiter_elems() const; // repeated .pg_query.Node on_conflict_set = 5 [json_name = "onConflictSet"]; int on_conflict_set_size() const; private: int _internal_on_conflict_set_size() const; public: void clear_on_conflict_set(); ::pg_query::Node* mutable_on_conflict_set(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_on_conflict_set(); private: const ::pg_query::Node& _internal_on_conflict_set(int index) const; ::pg_query::Node* _internal_add_on_conflict_set(); public: const ::pg_query::Node& on_conflict_set(int index) const; ::pg_query::Node* add_on_conflict_set(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& on_conflict_set() const; // repeated .pg_query.Node excl_rel_tlist = 8 [json_name = "exclRelTlist"]; int excl_rel_tlist_size() const; private: int _internal_excl_rel_tlist_size() const; public: void clear_excl_rel_tlist(); ::pg_query::Node* mutable_excl_rel_tlist(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_excl_rel_tlist(); private: const ::pg_query::Node& _internal_excl_rel_tlist(int index) const; ::pg_query::Node* _internal_add_excl_rel_tlist(); public: const ::pg_query::Node& excl_rel_tlist(int index) const; ::pg_query::Node* add_excl_rel_tlist(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& excl_rel_tlist() const; // .pg_query.Node arbiter_where = 3 [json_name = "arbiterWhere"]; bool has_arbiter_where() const; private: bool _internal_has_arbiter_where() const; public: void clear_arbiter_where(); const ::pg_query::Node& arbiter_where() const; PROTOBUF_NODISCARD ::pg_query::Node* release_arbiter_where(); ::pg_query::Node* mutable_arbiter_where(); void set_allocated_arbiter_where(::pg_query::Node* arbiter_where); private: const ::pg_query::Node& _internal_arbiter_where() const; ::pg_query::Node* _internal_mutable_arbiter_where(); public: void unsafe_arena_set_allocated_arbiter_where( ::pg_query::Node* arbiter_where); ::pg_query::Node* unsafe_arena_release_arbiter_where(); // .pg_query.Node on_conflict_where = 6 [json_name = "onConflictWhere"]; bool has_on_conflict_where() const; private: bool _internal_has_on_conflict_where() const; public: void clear_on_conflict_where(); const ::pg_query::Node& on_conflict_where() const; 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* on_conflict_where); private: const ::pg_query::Node& _internal_on_conflict_where() const; ::pg_query::Node* _internal_mutable_on_conflict_where(); public: void unsafe_arena_set_allocated_on_conflict_where( ::pg_query::Node* on_conflict_where); ::pg_query::Node* unsafe_arena_release_on_conflict_where(); // .pg_query.OnConflictAction action = 1 [json_name = "action"]; void clear_action(); ::pg_query::OnConflictAction action() const; void set_action(::pg_query::OnConflictAction value); private: ::pg_query::OnConflictAction _internal_action() const; void _internal_set_action(::pg_query::OnConflictAction value); public: // uint32 constraint = 4 [json_name = "constraint"]; void clear_constraint(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > arbiter_elems_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > on_conflict_set_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > excl_rel_tlist_; ::pg_query::Node* arbiter_where_; ::pg_query::Node* on_conflict_where_; int action_; uint32_t constraint_; int32_t excl_rel_index_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class IntoClause final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.IntoClause) */ { public: inline IntoClause() : IntoClause(nullptr) {} ~IntoClause() override; explicit PROTOBUF_CONSTEXPR IntoClause(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); IntoClause(const IntoClause& from); IntoClause(IntoClause&& from) noexcept : IntoClause() { *this = ::std::move(from); } inline IntoClause& operator=(const IntoClause& from) { CopyFrom(from); return *this; } inline IntoClause& operator=(IntoClause&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_IntoClause_default_instance_); } static constexpr int kIndexInFileMessages = 61; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(IntoClause* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- IntoClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const IntoClause& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const IntoClause& from) { IntoClause::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(IntoClause* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.IntoClause"; } protected: explicit IntoClause(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_col_names(); private: const ::pg_query::Node& _internal_col_names(int index) const; ::pg_query::Node* _internal_add_col_names(); public: const ::pg_query::Node& col_names(int index) const; ::pg_query::Node* add_col_names(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& col_names() const; // repeated .pg_query.Node options = 4 [json_name = "options"]; int options_size() const; private: int _internal_options_size() const; public: void clear_options(); ::pg_query::Node* mutable_options(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // string access_method = 3 [json_name = "accessMethod"]; void clear_access_method(); const std::string& access_method() const; template void set_access_method(ArgT0&& arg0, ArgT... args); std::string* mutable_access_method(); PROTOBUF_NODISCARD std::string* release_access_method(); void set_allocated_access_method(std::string* access_method); 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 void set_table_space_name(ArgT0&& arg0, ArgT... args); std::string* mutable_table_space_name(); PROTOBUF_NODISCARD std::string* release_table_space_name(); void set_allocated_table_space_name(std::string* table_space_name); private: const std::string& _internal_table_space_name() const; 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; private: bool _internal_has_rel() const; public: 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* rel); private: const ::pg_query::RangeVar& _internal_rel() const; ::pg_query::RangeVar* _internal_mutable_rel(); public: void unsafe_arena_set_allocated_rel( ::pg_query::RangeVar* rel); ::pg_query::RangeVar* unsafe_arena_release_rel(); // .pg_query.Node view_query = 7 [json_name = "viewQuery"]; bool has_view_query() const; private: bool _internal_has_view_query() const; public: void clear_view_query(); const ::pg_query::Node& view_query() const; PROTOBUF_NODISCARD ::pg_query::Node* release_view_query(); ::pg_query::Node* mutable_view_query(); void set_allocated_view_query(::pg_query::Node* view_query); private: const ::pg_query::Node& _internal_view_query() const; ::pg_query::Node* _internal_mutable_view_query(); public: void unsafe_arena_set_allocated_view_query( ::pg_query::Node* view_query); ::pg_query::Node* unsafe_arena_release_view_query(); // .pg_query.OnCommitAction on_commit = 5 [json_name = "onCommit"]; void clear_on_commit(); ::pg_query::OnCommitAction on_commit() const; void set_on_commit(::pg_query::OnCommitAction value); private: ::pg_query::OnCommitAction _internal_on_commit() const; void _internal_set_on_commit(::pg_query::OnCommitAction value); public: // bool skip_data = 8 [json_name = "skipData"]; void clear_skip_data(); bool skip_data() const; void set_skip_data(bool value); private: bool _internal_skip_data() const; void _internal_set_skip_data(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.IntoClause) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > col_names_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr access_method_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_space_name_; ::pg_query::RangeVar* rel_; ::pg_query::Node* view_query_; int on_commit_; bool skip_data_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class MergeAction final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.MergeAction) */ { public: inline MergeAction() : MergeAction(nullptr) {} ~MergeAction() override; explicit PROTOBUF_CONSTEXPR MergeAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); MergeAction(const MergeAction& 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 (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_MergeAction_default_instance_); } static constexpr int kIndexInFileMessages = 62; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(MergeAction* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- MergeAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const MergeAction& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const MergeAction& from) { MergeAction::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(MergeAction* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.MergeAction"; } protected: explicit MergeAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_target_list(); private: const ::pg_query::Node& _internal_target_list(int index) const; ::pg_query::Node* _internal_add_target_list(); public: const ::pg_query::Node& target_list(int index) const; ::pg_query::Node* add_target_list(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& target_list() const; // repeated .pg_query.Node 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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_update_colnos(); private: const ::pg_query::Node& _internal_update_colnos(int index) const; ::pg_query::Node* _internal_add_update_colnos(); public: const ::pg_query::Node& update_colnos(int index) const; ::pg_query::Node* add_update_colnos(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& update_colnos() const; // .pg_query.Node qual = 4 [json_name = "qual"]; bool has_qual() const; private: bool _internal_has_qual() const; public: void clear_qual(); const ::pg_query::Node& qual() const; PROTOBUF_NODISCARD ::pg_query::Node* release_qual(); ::pg_query::Node* mutable_qual(); void set_allocated_qual(::pg_query::Node* qual); private: const ::pg_query::Node& _internal_qual() const; ::pg_query::Node* _internal_mutable_qual(); public: void unsafe_arena_set_allocated_qual( ::pg_query::Node* qual); ::pg_query::Node* unsafe_arena_release_qual(); // 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > target_list_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > update_colnos_; ::pg_query::Node* qual_; bool matched_; int command_type_; int override_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class RawStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RawStmt) */ { public: inline RawStmt() : RawStmt(nullptr) {} ~RawStmt() override; explicit PROTOBUF_CONSTEXPR RawStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); RawStmt(const RawStmt& from); RawStmt(RawStmt&& from) noexcept : RawStmt() { *this = ::std::move(from); } inline RawStmt& operator=(const RawStmt& from) { CopyFrom(from); return *this; } inline RawStmt& operator=(RawStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_RawStmt_default_instance_); } static constexpr int kIndexInFileMessages = 63; friend void swap(RawStmt& a, RawStmt& b) { a.Swap(&b); } inline void Swap(RawStmt* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(RawStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- RawStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const RawStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const RawStmt& from) { RawStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(RawStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.RawStmt"; } protected: explicit RawStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_stmt() const; public: 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* stmt); private: const ::pg_query::Node& _internal_stmt() const; ::pg_query::Node* _internal_mutable_stmt(); public: void unsafe_arena_set_allocated_stmt( ::pg_query::Node* stmt); ::pg_query::Node* unsafe_arena_release_stmt(); // int32 stmt_location = 2 [json_name = "stmt_location"]; void clear_stmt_location(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::Node* stmt_; int32_t stmt_location_; int32_t stmt_len_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class Query final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.Query) */ { public: inline Query() : Query(nullptr) {} ~Query() override; explicit PROTOBUF_CONSTEXPR Query(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); Query(const Query& from); Query(Query&& from) noexcept : Query() { *this = ::std::move(from); } inline Query& operator=(const Query& from) { CopyFrom(from); return *this; } inline Query& operator=(Query&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_Query_default_instance_); } static constexpr int kIndexInFileMessages = 64; friend void swap(Query& a, Query& b) { a.Swap(&b); } inline void Swap(Query* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(Query* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- Query* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Query& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const Query& from) { Query::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Query* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.Query"; } protected: explicit Query(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kCteListFieldNumber = 16, kRtableFieldNumber = 17, kMergeActionListFieldNumber = 19, kTargetListFieldNumber = 21, kReturningListFieldNumber = 24, kGroupClauseFieldNumber = 25, kGroupingSetsFieldNumber = 27, kWindowClauseFieldNumber = 29, kDistinctClauseFieldNumber = 30, kSortClauseFieldNumber = 31, kRowMarksFieldNumber = 35, kConstraintDepsFieldNumber = 37, kWithCheckOptionsFieldNumber = 38, kUtilityStmtFieldNumber = 4, kJointreeFieldNumber = 18, kOnConflictFieldNumber = 23, kHavingQualFieldNumber = 28, kLimitOffsetFieldNumber = 32, kLimitCountFieldNumber = 33, kSetOperationsFieldNumber = 36, 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 = 20, kOverrideFieldNumber = 22, kGroupDistinctFieldNumber = 26, kLimitOptionFieldNumber = 34, kStmtLocationFieldNumber = 39, kStmtLenFieldNumber = 40, }; // 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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_cte_list(); private: const ::pg_query::Node& _internal_cte_list(int index) const; ::pg_query::Node* _internal_add_cte_list(); public: const ::pg_query::Node& cte_list(int index) const; ::pg_query::Node* add_cte_list(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& cte_list() const; // repeated .pg_query.Node rtable = 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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_rtable(); private: const ::pg_query::Node& _internal_rtable(int index) const; ::pg_query::Node* _internal_add_rtable(); public: const ::pg_query::Node& rtable(int index) const; ::pg_query::Node* add_rtable(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& rtable() const; // repeated .pg_query.Node merge_action_list = 19 [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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_merge_action_list(); private: const ::pg_query::Node& _internal_merge_action_list(int index) const; ::pg_query::Node* _internal_add_merge_action_list(); public: const ::pg_query::Node& merge_action_list(int index) const; ::pg_query::Node* add_merge_action_list(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& merge_action_list() const; // repeated .pg_query.Node target_list = 21 [json_name = "targetList"]; int target_list_size() const; private: int _internal_target_list_size() const; public: void clear_target_list(); ::pg_query::Node* mutable_target_list(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_target_list(); private: const ::pg_query::Node& _internal_target_list(int index) const; ::pg_query::Node* _internal_add_target_list(); public: const ::pg_query::Node& target_list(int index) const; ::pg_query::Node* add_target_list(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& target_list() const; // repeated .pg_query.Node returning_list = 24 [json_name = "returningList"]; int returning_list_size() const; private: int _internal_returning_list_size() const; public: void clear_returning_list(); ::pg_query::Node* mutable_returning_list(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_returning_list(); private: const ::pg_query::Node& _internal_returning_list(int index) const; ::pg_query::Node* _internal_add_returning_list(); public: const ::pg_query::Node& returning_list(int index) const; ::pg_query::Node* add_returning_list(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& returning_list() const; // repeated .pg_query.Node group_clause = 25 [json_name = "groupClause"]; int group_clause_size() const; private: int _internal_group_clause_size() const; public: void clear_group_clause(); ::pg_query::Node* mutable_group_clause(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_group_clause(); private: const ::pg_query::Node& _internal_group_clause(int index) const; ::pg_query::Node* _internal_add_group_clause(); public: const ::pg_query::Node& group_clause(int index) const; ::pg_query::Node* add_group_clause(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& group_clause() const; // repeated .pg_query.Node grouping_sets = 27 [json_name = "groupingSets"]; int grouping_sets_size() const; private: int _internal_grouping_sets_size() const; public: void clear_grouping_sets(); ::pg_query::Node* mutable_grouping_sets(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_grouping_sets(); private: const ::pg_query::Node& _internal_grouping_sets(int index) const; ::pg_query::Node* _internal_add_grouping_sets(); public: const ::pg_query::Node& grouping_sets(int index) const; ::pg_query::Node* add_grouping_sets(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& grouping_sets() const; // repeated .pg_query.Node window_clause = 29 [json_name = "windowClause"]; int window_clause_size() const; private: int _internal_window_clause_size() const; public: void clear_window_clause(); ::pg_query::Node* mutable_window_clause(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_window_clause(); private: const ::pg_query::Node& _internal_window_clause(int index) const; ::pg_query::Node* _internal_add_window_clause(); public: const ::pg_query::Node& window_clause(int index) const; ::pg_query::Node* add_window_clause(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& window_clause() const; // repeated .pg_query.Node distinct_clause = 30 [json_name = "distinctClause"]; int distinct_clause_size() const; private: int _internal_distinct_clause_size() const; public: void clear_distinct_clause(); ::pg_query::Node* mutable_distinct_clause(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_distinct_clause(); private: const ::pg_query::Node& _internal_distinct_clause(int index) const; ::pg_query::Node* _internal_add_distinct_clause(); public: const ::pg_query::Node& distinct_clause(int index) const; ::pg_query::Node* add_distinct_clause(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& distinct_clause() const; // repeated .pg_query.Node sort_clause = 31 [json_name = "sortClause"]; int sort_clause_size() const; private: int _internal_sort_clause_size() const; public: void clear_sort_clause(); ::pg_query::Node* mutable_sort_clause(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_sort_clause(); private: const ::pg_query::Node& _internal_sort_clause(int index) const; ::pg_query::Node* _internal_add_sort_clause(); public: const ::pg_query::Node& sort_clause(int index) const; ::pg_query::Node* add_sort_clause(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& sort_clause() const; // repeated .pg_query.Node row_marks = 35 [json_name = "rowMarks"]; int row_marks_size() const; private: int _internal_row_marks_size() const; public: void clear_row_marks(); ::pg_query::Node* mutable_row_marks(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_row_marks(); private: const ::pg_query::Node& _internal_row_marks(int index) const; ::pg_query::Node* _internal_add_row_marks(); public: const ::pg_query::Node& row_marks(int index) const; ::pg_query::Node* add_row_marks(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& row_marks() const; // repeated .pg_query.Node constraint_deps = 37 [json_name = "constraintDeps"]; int constraint_deps_size() const; private: int _internal_constraint_deps_size() const; public: void clear_constraint_deps(); ::pg_query::Node* mutable_constraint_deps(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_constraint_deps(); private: const ::pg_query::Node& _internal_constraint_deps(int index) const; ::pg_query::Node* _internal_add_constraint_deps(); public: const ::pg_query::Node& constraint_deps(int index) const; ::pg_query::Node* add_constraint_deps(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& constraint_deps() const; // repeated .pg_query.Node with_check_options = 38 [json_name = "withCheckOptions"]; int with_check_options_size() const; private: int _internal_with_check_options_size() const; public: void clear_with_check_options(); ::pg_query::Node* mutable_with_check_options(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_with_check_options(); private: const ::pg_query::Node& _internal_with_check_options(int index) const; ::pg_query::Node* _internal_add_with_check_options(); public: const ::pg_query::Node& with_check_options(int index) const; ::pg_query::Node* add_with_check_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& with_check_options() const; // .pg_query.Node utility_stmt = 4 [json_name = "utilityStmt"]; bool has_utility_stmt() const; private: bool _internal_has_utility_stmt() const; public: void clear_utility_stmt(); const ::pg_query::Node& utility_stmt() const; PROTOBUF_NODISCARD ::pg_query::Node* release_utility_stmt(); ::pg_query::Node* mutable_utility_stmt(); void set_allocated_utility_stmt(::pg_query::Node* utility_stmt); private: const ::pg_query::Node& _internal_utility_stmt() const; ::pg_query::Node* _internal_mutable_utility_stmt(); public: void unsafe_arena_set_allocated_utility_stmt( ::pg_query::Node* utility_stmt); ::pg_query::Node* unsafe_arena_release_utility_stmt(); // .pg_query.FromExpr jointree = 18 [json_name = "jointree"]; bool has_jointree() const; private: bool _internal_has_jointree() const; public: 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* jointree); private: const ::pg_query::FromExpr& _internal_jointree() const; ::pg_query::FromExpr* _internal_mutable_jointree(); public: void unsafe_arena_set_allocated_jointree( ::pg_query::FromExpr* jointree); ::pg_query::FromExpr* unsafe_arena_release_jointree(); // .pg_query.OnConflictExpr on_conflict = 23 [json_name = "onConflict"]; bool has_on_conflict() const; private: bool _internal_has_on_conflict() const; public: void clear_on_conflict(); const ::pg_query::OnConflictExpr& on_conflict() const; PROTOBUF_NODISCARD ::pg_query::OnConflictExpr* release_on_conflict(); ::pg_query::OnConflictExpr* mutable_on_conflict(); void set_allocated_on_conflict(::pg_query::OnConflictExpr* on_conflict); private: const ::pg_query::OnConflictExpr& _internal_on_conflict() const; ::pg_query::OnConflictExpr* _internal_mutable_on_conflict(); public: void unsafe_arena_set_allocated_on_conflict( ::pg_query::OnConflictExpr* on_conflict); ::pg_query::OnConflictExpr* unsafe_arena_release_on_conflict(); // .pg_query.Node having_qual = 28 [json_name = "havingQual"]; bool has_having_qual() const; private: bool _internal_has_having_qual() const; public: void clear_having_qual(); const ::pg_query::Node& having_qual() const; PROTOBUF_NODISCARD ::pg_query::Node* release_having_qual(); ::pg_query::Node* mutable_having_qual(); void set_allocated_having_qual(::pg_query::Node* having_qual); private: const ::pg_query::Node& _internal_having_qual() const; ::pg_query::Node* _internal_mutable_having_qual(); public: void unsafe_arena_set_allocated_having_qual( ::pg_query::Node* having_qual); ::pg_query::Node* unsafe_arena_release_having_qual(); // .pg_query.Node limit_offset = 32 [json_name = "limitOffset"]; bool has_limit_offset() const; private: bool _internal_has_limit_offset() const; public: void clear_limit_offset(); const ::pg_query::Node& limit_offset() const; PROTOBUF_NODISCARD ::pg_query::Node* release_limit_offset(); ::pg_query::Node* mutable_limit_offset(); void set_allocated_limit_offset(::pg_query::Node* limit_offset); private: const ::pg_query::Node& _internal_limit_offset() const; ::pg_query::Node* _internal_mutable_limit_offset(); public: void unsafe_arena_set_allocated_limit_offset( ::pg_query::Node* limit_offset); ::pg_query::Node* unsafe_arena_release_limit_offset(); // .pg_query.Node limit_count = 33 [json_name = "limitCount"]; bool has_limit_count() const; private: bool _internal_has_limit_count() const; public: void clear_limit_count(); const ::pg_query::Node& limit_count() const; PROTOBUF_NODISCARD ::pg_query::Node* release_limit_count(); ::pg_query::Node* mutable_limit_count(); void set_allocated_limit_count(::pg_query::Node* limit_count); private: const ::pg_query::Node& _internal_limit_count() const; ::pg_query::Node* _internal_mutable_limit_count(); public: void unsafe_arena_set_allocated_limit_count( ::pg_query::Node* limit_count); ::pg_query::Node* unsafe_arena_release_limit_count(); // .pg_query.Node set_operations = 36 [json_name = "setOperations"]; bool has_set_operations() const; private: bool _internal_has_set_operations() const; public: void clear_set_operations(); const ::pg_query::Node& set_operations() const; PROTOBUF_NODISCARD ::pg_query::Node* release_set_operations(); ::pg_query::Node* mutable_set_operations(); void set_allocated_set_operations(::pg_query::Node* set_operations); private: const ::pg_query::Node& _internal_set_operations() const; ::pg_query::Node* _internal_mutable_set_operations(); public: void unsafe_arena_set_allocated_set_operations( ::pg_query::Node* set_operations); ::pg_query::Node* unsafe_arena_release_set_operations(); // .pg_query.CmdType command_type = 1 [json_name = "commandType"]; void clear_command_type(); ::pg_query::CmdType command_type() const; void set_command_type(::pg_query::CmdType value); private: ::pg_query::CmdType _internal_command_type() const; void _internal_set_command_type(::pg_query::CmdType value); public: // .pg_query.QuerySource query_source = 2 [json_name = "querySource"]; void clear_query_source(); ::pg_query::QuerySource query_source() const; void set_query_source(::pg_query::QuerySource value); private: ::pg_query::QuerySource _internal_query_source() const; void _internal_set_query_source(::pg_query::QuerySource value); public: // int32 result_relation = 5 [json_name = "resultRelation"]; void clear_result_relation(); 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 = 20 [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 = 22 [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 = 26 [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 = 34 [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 = 39 [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 = 40 [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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > cte_list_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > rtable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > merge_action_list_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > target_list_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > returning_list_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > group_clause_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > grouping_sets_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > window_clause_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > distinct_clause_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > sort_clause_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > row_marks_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > constraint_deps_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > with_check_options_; ::pg_query::Node* utility_stmt_; ::pg_query::FromExpr* jointree_; ::pg_query::OnConflictExpr* on_conflict_; ::pg_query::Node* having_qual_; ::pg_query::Node* limit_offset_; ::pg_query::Node* limit_count_; ::pg_query::Node* set_operations_; int command_type_; int query_source_; 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_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class InsertStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.InsertStmt) */ { public: inline InsertStmt() : InsertStmt(nullptr) {} ~InsertStmt() override; explicit PROTOBUF_CONSTEXPR InsertStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); InsertStmt(const InsertStmt& from); InsertStmt(InsertStmt&& from) noexcept : InsertStmt() { *this = ::std::move(from); } inline InsertStmt& operator=(const InsertStmt& from) { CopyFrom(from); return *this; } inline InsertStmt& operator=(InsertStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_InsertStmt_default_instance_); } static constexpr int kIndexInFileMessages = 65; friend void swap(InsertStmt& a, InsertStmt& b) { a.Swap(&b); } inline void Swap(InsertStmt* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(InsertStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- InsertStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const InsertStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const InsertStmt& from) { InsertStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(InsertStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.InsertStmt"; } protected: explicit InsertStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_cols(); private: const ::pg_query::Node& _internal_cols(int index) const; ::pg_query::Node* _internal_add_cols(); public: const ::pg_query::Node& cols(int index) const; ::pg_query::Node* add_cols(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& cols() const; // repeated .pg_query.Node returning_list = 5 [json_name = "returningList"]; int returning_list_size() const; private: int _internal_returning_list_size() const; public: void clear_returning_list(); ::pg_query::Node* mutable_returning_list(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_returning_list(); private: const ::pg_query::Node& _internal_returning_list(int index) const; ::pg_query::Node* _internal_add_returning_list(); public: const ::pg_query::Node& returning_list(int index) const; ::pg_query::Node* add_returning_list(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& returning_list() const; // .pg_query.RangeVar relation = 1 [json_name = "relation"]; bool has_relation() const; private: bool _internal_has_relation() const; public: void clear_relation(); const ::pg_query::RangeVar& relation() const; PROTOBUF_NODISCARD ::pg_query::RangeVar* release_relation(); ::pg_query::RangeVar* mutable_relation(); void set_allocated_relation(::pg_query::RangeVar* relation); private: const ::pg_query::RangeVar& _internal_relation() const; ::pg_query::RangeVar* _internal_mutable_relation(); public: void unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation); ::pg_query::RangeVar* unsafe_arena_release_relation(); // .pg_query.Node select_stmt = 3 [json_name = "selectStmt"]; bool has_select_stmt() const; private: bool _internal_has_select_stmt() const; public: void clear_select_stmt(); const ::pg_query::Node& select_stmt() const; PROTOBUF_NODISCARD ::pg_query::Node* release_select_stmt(); ::pg_query::Node* mutable_select_stmt(); void set_allocated_select_stmt(::pg_query::Node* select_stmt); private: const ::pg_query::Node& _internal_select_stmt() const; ::pg_query::Node* _internal_mutable_select_stmt(); public: void unsafe_arena_set_allocated_select_stmt( ::pg_query::Node* select_stmt); ::pg_query::Node* unsafe_arena_release_select_stmt(); // .pg_query.OnConflictClause on_conflict_clause = 4 [json_name = "onConflictClause"]; bool has_on_conflict_clause() const; private: bool _internal_has_on_conflict_clause() const; public: void clear_on_conflict_clause(); const ::pg_query::OnConflictClause& on_conflict_clause() const; 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* on_conflict_clause); private: const ::pg_query::OnConflictClause& _internal_on_conflict_clause() const; ::pg_query::OnConflictClause* _internal_mutable_on_conflict_clause(); public: void unsafe_arena_set_allocated_on_conflict_clause( ::pg_query::OnConflictClause* on_conflict_clause); ::pg_query::OnConflictClause* unsafe_arena_release_on_conflict_clause(); // .pg_query.WithClause with_clause = 6 [json_name = "withClause"]; bool has_with_clause() const; private: bool _internal_has_with_clause() const; public: void clear_with_clause(); const ::pg_query::WithClause& with_clause() const; PROTOBUF_NODISCARD ::pg_query::WithClause* release_with_clause(); ::pg_query::WithClause* mutable_with_clause(); void set_allocated_with_clause(::pg_query::WithClause* with_clause); private: const ::pg_query::WithClause& _internal_with_clause() const; ::pg_query::WithClause* _internal_mutable_with_clause(); public: void unsafe_arena_set_allocated_with_clause( ::pg_query::WithClause* with_clause); ::pg_query::WithClause* unsafe_arena_release_with_clause(); // .pg_query.OverridingKind override = 7 [json_name = "override"]; void clear_override(); ::pg_query::OverridingKind override() const; void set_override(::pg_query::OverridingKind value); private: ::pg_query::OverridingKind _internal_override() const; void _internal_set_override(::pg_query::OverridingKind value); public: // @@protoc_insertion_point(class_scope:pg_query.InsertStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > cols_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > returning_list_; ::pg_query::RangeVar* relation_; ::pg_query::Node* select_stmt_; ::pg_query::OnConflictClause* on_conflict_clause_; ::pg_query::WithClause* with_clause_; int override_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class DeleteStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DeleteStmt) */ { public: inline DeleteStmt() : DeleteStmt(nullptr) {} ~DeleteStmt() override; explicit PROTOBUF_CONSTEXPR DeleteStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); DeleteStmt(const DeleteStmt& from); DeleteStmt(DeleteStmt&& from) noexcept : DeleteStmt() { *this = ::std::move(from); } inline DeleteStmt& operator=(const DeleteStmt& from) { CopyFrom(from); return *this; } inline DeleteStmt& operator=(DeleteStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_DeleteStmt_default_instance_); } static constexpr int kIndexInFileMessages = 66; friend void swap(DeleteStmt& a, DeleteStmt& b) { a.Swap(&b); } inline void Swap(DeleteStmt* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(DeleteStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- DeleteStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DeleteStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const DeleteStmt& from) { DeleteStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DeleteStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.DeleteStmt"; } protected: explicit DeleteStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_using_clause(); private: const ::pg_query::Node& _internal_using_clause(int index) const; ::pg_query::Node* _internal_add_using_clause(); public: const ::pg_query::Node& using_clause(int index) const; ::pg_query::Node* add_using_clause(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& using_clause() const; // repeated .pg_query.Node returning_list = 4 [json_name = "returningList"]; int returning_list_size() const; private: int _internal_returning_list_size() const; public: void clear_returning_list(); ::pg_query::Node* mutable_returning_list(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_returning_list(); private: const ::pg_query::Node& _internal_returning_list(int index) const; ::pg_query::Node* _internal_add_returning_list(); public: const ::pg_query::Node& returning_list(int index) const; ::pg_query::Node* add_returning_list(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& returning_list() const; // .pg_query.RangeVar relation = 1 [json_name = "relation"]; bool has_relation() const; private: bool _internal_has_relation() const; public: void clear_relation(); const ::pg_query::RangeVar& relation() const; PROTOBUF_NODISCARD ::pg_query::RangeVar* release_relation(); ::pg_query::RangeVar* mutable_relation(); void set_allocated_relation(::pg_query::RangeVar* relation); private: const ::pg_query::RangeVar& _internal_relation() const; ::pg_query::RangeVar* _internal_mutable_relation(); public: void unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation); ::pg_query::RangeVar* unsafe_arena_release_relation(); // .pg_query.Node where_clause = 3 [json_name = "whereClause"]; bool has_where_clause() const; private: bool _internal_has_where_clause() const; public: void clear_where_clause(); const ::pg_query::Node& where_clause() const; PROTOBUF_NODISCARD ::pg_query::Node* release_where_clause(); ::pg_query::Node* mutable_where_clause(); void set_allocated_where_clause(::pg_query::Node* where_clause); private: const ::pg_query::Node& _internal_where_clause() const; ::pg_query::Node* _internal_mutable_where_clause(); public: void unsafe_arena_set_allocated_where_clause( ::pg_query::Node* where_clause); ::pg_query::Node* unsafe_arena_release_where_clause(); // .pg_query.WithClause with_clause = 5 [json_name = "withClause"]; bool has_with_clause() const; private: bool _internal_has_with_clause() const; public: void clear_with_clause(); const ::pg_query::WithClause& with_clause() const; PROTOBUF_NODISCARD ::pg_query::WithClause* release_with_clause(); ::pg_query::WithClause* mutable_with_clause(); void set_allocated_with_clause(::pg_query::WithClause* with_clause); private: const ::pg_query::WithClause& _internal_with_clause() const; ::pg_query::WithClause* _internal_mutable_with_clause(); public: void unsafe_arena_set_allocated_with_clause( ::pg_query::WithClause* with_clause); ::pg_query::WithClause* unsafe_arena_release_with_clause(); // @@protoc_insertion_point(class_scope:pg_query.DeleteStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > using_clause_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > returning_list_; ::pg_query::RangeVar* relation_; ::pg_query::Node* where_clause_; ::pg_query::WithClause* with_clause_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class UpdateStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.UpdateStmt) */ { public: inline UpdateStmt() : UpdateStmt(nullptr) {} ~UpdateStmt() override; explicit PROTOBUF_CONSTEXPR UpdateStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); UpdateStmt(const UpdateStmt& from); UpdateStmt(UpdateStmt&& from) noexcept : UpdateStmt() { *this = ::std::move(from); } inline UpdateStmt& operator=(const UpdateStmt& from) { CopyFrom(from); return *this; } inline UpdateStmt& operator=(UpdateStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_UpdateStmt_default_instance_); } static constexpr int kIndexInFileMessages = 67; friend void swap(UpdateStmt& a, UpdateStmt& b) { a.Swap(&b); } inline void Swap(UpdateStmt* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(UpdateStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- UpdateStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const UpdateStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const UpdateStmt& from) { UpdateStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(UpdateStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.UpdateStmt"; } protected: explicit UpdateStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_target_list(); private: const ::pg_query::Node& _internal_target_list(int index) const; ::pg_query::Node* _internal_add_target_list(); public: const ::pg_query::Node& target_list(int index) const; ::pg_query::Node* add_target_list(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& target_list() const; // repeated .pg_query.Node from_clause = 4 [json_name = "fromClause"]; int from_clause_size() const; private: int _internal_from_clause_size() const; public: void clear_from_clause(); ::pg_query::Node* mutable_from_clause(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_from_clause(); private: const ::pg_query::Node& _internal_from_clause(int index) const; ::pg_query::Node* _internal_add_from_clause(); public: const ::pg_query::Node& from_clause(int index) const; ::pg_query::Node* add_from_clause(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& from_clause() const; // repeated .pg_query.Node returning_list = 5 [json_name = "returningList"]; int returning_list_size() const; private: int _internal_returning_list_size() const; public: void clear_returning_list(); ::pg_query::Node* mutable_returning_list(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_returning_list(); private: const ::pg_query::Node& _internal_returning_list(int index) const; ::pg_query::Node* _internal_add_returning_list(); public: const ::pg_query::Node& returning_list(int index) const; ::pg_query::Node* add_returning_list(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& returning_list() const; // .pg_query.RangeVar relation = 1 [json_name = "relation"]; bool has_relation() const; private: bool _internal_has_relation() const; public: void clear_relation(); const ::pg_query::RangeVar& relation() const; PROTOBUF_NODISCARD ::pg_query::RangeVar* release_relation(); ::pg_query::RangeVar* mutable_relation(); void set_allocated_relation(::pg_query::RangeVar* relation); private: const ::pg_query::RangeVar& _internal_relation() const; ::pg_query::RangeVar* _internal_mutable_relation(); public: void unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation); ::pg_query::RangeVar* unsafe_arena_release_relation(); // .pg_query.Node where_clause = 3 [json_name = "whereClause"]; bool has_where_clause() const; private: bool _internal_has_where_clause() const; public: void clear_where_clause(); const ::pg_query::Node& where_clause() const; PROTOBUF_NODISCARD ::pg_query::Node* release_where_clause(); ::pg_query::Node* mutable_where_clause(); void set_allocated_where_clause(::pg_query::Node* where_clause); private: const ::pg_query::Node& _internal_where_clause() const; ::pg_query::Node* _internal_mutable_where_clause(); public: void unsafe_arena_set_allocated_where_clause( ::pg_query::Node* where_clause); ::pg_query::Node* unsafe_arena_release_where_clause(); // .pg_query.WithClause with_clause = 6 [json_name = "withClause"]; bool has_with_clause() const; private: bool _internal_has_with_clause() const; public: void clear_with_clause(); const ::pg_query::WithClause& with_clause() const; PROTOBUF_NODISCARD ::pg_query::WithClause* release_with_clause(); ::pg_query::WithClause* mutable_with_clause(); void set_allocated_with_clause(::pg_query::WithClause* with_clause); private: const ::pg_query::WithClause& _internal_with_clause() const; ::pg_query::WithClause* _internal_mutable_with_clause(); public: void unsafe_arena_set_allocated_with_clause( ::pg_query::WithClause* with_clause); ::pg_query::WithClause* unsafe_arena_release_with_clause(); // @@protoc_insertion_point(class_scope:pg_query.UpdateStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > target_list_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > from_clause_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > returning_list_; ::pg_query::RangeVar* relation_; ::pg_query::Node* where_clause_; ::pg_query::WithClause* with_clause_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class MergeStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.MergeStmt) */ { public: inline MergeStmt() : MergeStmt(nullptr) {} ~MergeStmt() override; explicit PROTOBUF_CONSTEXPR MergeStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); MergeStmt(const MergeStmt& 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 (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_MergeStmt_default_instance_); } static constexpr int kIndexInFileMessages = 68; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(MergeStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- MergeStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const MergeStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const MergeStmt& from) { MergeStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(MergeStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.MergeStmt"; } protected: explicit MergeStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_merge_when_clauses(); private: const ::pg_query::Node& _internal_merge_when_clauses(int index) const; ::pg_query::Node* _internal_add_merge_when_clauses(); public: const ::pg_query::Node& merge_when_clauses(int index) const; ::pg_query::Node* add_merge_when_clauses(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& merge_when_clauses() const; // .pg_query.RangeVar relation = 1 [json_name = "relation"]; bool has_relation() const; private: bool _internal_has_relation() const; public: void clear_relation(); const ::pg_query::RangeVar& relation() const; PROTOBUF_NODISCARD ::pg_query::RangeVar* release_relation(); ::pg_query::RangeVar* mutable_relation(); void set_allocated_relation(::pg_query::RangeVar* relation); private: const ::pg_query::RangeVar& _internal_relation() const; ::pg_query::RangeVar* _internal_mutable_relation(); public: void unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation); ::pg_query::RangeVar* unsafe_arena_release_relation(); // .pg_query.Node source_relation = 2 [json_name = "sourceRelation"]; bool has_source_relation() const; private: bool _internal_has_source_relation() const; public: 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* source_relation); private: const ::pg_query::Node& _internal_source_relation() const; ::pg_query::Node* _internal_mutable_source_relation(); public: void unsafe_arena_set_allocated_source_relation( ::pg_query::Node* source_relation); ::pg_query::Node* unsafe_arena_release_source_relation(); // .pg_query.Node join_condition = 3 [json_name = "joinCondition"]; bool has_join_condition() const; private: bool _internal_has_join_condition() const; public: 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* join_condition); private: const ::pg_query::Node& _internal_join_condition() const; ::pg_query::Node* _internal_mutable_join_condition(); public: void unsafe_arena_set_allocated_join_condition( ::pg_query::Node* join_condition); ::pg_query::Node* unsafe_arena_release_join_condition(); // .pg_query.WithClause with_clause = 5 [json_name = "withClause"]; bool has_with_clause() const; private: bool _internal_has_with_clause() const; public: void clear_with_clause(); const ::pg_query::WithClause& with_clause() const; PROTOBUF_NODISCARD ::pg_query::WithClause* release_with_clause(); ::pg_query::WithClause* mutable_with_clause(); void set_allocated_with_clause(::pg_query::WithClause* with_clause); private: const ::pg_query::WithClause& _internal_with_clause() const; ::pg_query::WithClause* _internal_mutable_with_clause(); public: void unsafe_arena_set_allocated_with_clause( ::pg_query::WithClause* with_clause); ::pg_query::WithClause* unsafe_arena_release_with_clause(); // @@protoc_insertion_point(class_scope:pg_query.MergeStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::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_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class SelectStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.SelectStmt) */ { public: inline SelectStmt() : SelectStmt(nullptr) {} ~SelectStmt() override; explicit PROTOBUF_CONSTEXPR SelectStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); SelectStmt(const SelectStmt& from); SelectStmt(SelectStmt&& from) noexcept : SelectStmt() { *this = ::std::move(from); } inline SelectStmt& operator=(const SelectStmt& from) { CopyFrom(from); return *this; } inline SelectStmt& operator=(SelectStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_SelectStmt_default_instance_); } static constexpr int kIndexInFileMessages = 69; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SelectStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- SelectStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const SelectStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const SelectStmt& from) { SelectStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(SelectStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.SelectStmt"; } protected: explicit SelectStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_distinct_clause(); private: const ::pg_query::Node& _internal_distinct_clause(int index) const; ::pg_query::Node* _internal_add_distinct_clause(); public: const ::pg_query::Node& distinct_clause(int index) const; ::pg_query::Node* add_distinct_clause(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& distinct_clause() const; // repeated .pg_query.Node target_list = 3 [json_name = "targetList"]; int target_list_size() const; private: int _internal_target_list_size() const; public: void clear_target_list(); ::pg_query::Node* mutable_target_list(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_target_list(); private: const ::pg_query::Node& _internal_target_list(int index) const; ::pg_query::Node* _internal_add_target_list(); public: const ::pg_query::Node& target_list(int index) const; ::pg_query::Node* add_target_list(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& target_list() const; // repeated .pg_query.Node from_clause = 4 [json_name = "fromClause"]; int from_clause_size() const; private: int _internal_from_clause_size() const; public: void clear_from_clause(); ::pg_query::Node* mutable_from_clause(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_from_clause(); private: const ::pg_query::Node& _internal_from_clause(int index) const; ::pg_query::Node* _internal_add_from_clause(); public: const ::pg_query::Node& from_clause(int index) const; ::pg_query::Node* add_from_clause(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& from_clause() const; // repeated .pg_query.Node group_clause = 6 [json_name = "groupClause"]; int group_clause_size() const; private: int _internal_group_clause_size() const; public: void clear_group_clause(); ::pg_query::Node* mutable_group_clause(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_group_clause(); private: const ::pg_query::Node& _internal_group_clause(int index) const; ::pg_query::Node* _internal_add_group_clause(); public: const ::pg_query::Node& group_clause(int index) const; ::pg_query::Node* add_group_clause(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& group_clause() const; // repeated .pg_query.Node window_clause = 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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_window_clause(); private: const ::pg_query::Node& _internal_window_clause(int index) const; ::pg_query::Node* _internal_add_window_clause(); public: const ::pg_query::Node& window_clause(int index) const; ::pg_query::Node* add_window_clause(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& window_clause() const; // repeated .pg_query.Node values_lists = 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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_values_lists(); private: const ::pg_query::Node& _internal_values_lists(int index) const; ::pg_query::Node* _internal_add_values_lists(); public: const ::pg_query::Node& values_lists(int index) const; ::pg_query::Node* add_values_lists(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& values_lists() const; // repeated .pg_query.Node sort_clause = 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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_sort_clause(); private: const ::pg_query::Node& _internal_sort_clause(int index) const; ::pg_query::Node* _internal_add_sort_clause(); public: const ::pg_query::Node& sort_clause(int index) const; ::pg_query::Node* add_sort_clause(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& sort_clause() const; // repeated .pg_query.Node locking_clause = 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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_locking_clause(); private: const ::pg_query::Node& _internal_locking_clause(int index) const; ::pg_query::Node* _internal_add_locking_clause(); public: const ::pg_query::Node& locking_clause(int index) const; ::pg_query::Node* add_locking_clause(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& locking_clause() const; // .pg_query.IntoClause into_clause = 2 [json_name = "intoClause"]; bool has_into_clause() const; private: bool _internal_has_into_clause() const; public: void clear_into_clause(); const ::pg_query::IntoClause& into_clause() const; PROTOBUF_NODISCARD ::pg_query::IntoClause* release_into_clause(); ::pg_query::IntoClause* mutable_into_clause(); void set_allocated_into_clause(::pg_query::IntoClause* into_clause); private: const ::pg_query::IntoClause& _internal_into_clause() const; ::pg_query::IntoClause* _internal_mutable_into_clause(); public: void unsafe_arena_set_allocated_into_clause( ::pg_query::IntoClause* into_clause); ::pg_query::IntoClause* unsafe_arena_release_into_clause(); // .pg_query.Node where_clause = 5 [json_name = "whereClause"]; bool has_where_clause() const; private: bool _internal_has_where_clause() const; public: void clear_where_clause(); const ::pg_query::Node& where_clause() const; PROTOBUF_NODISCARD ::pg_query::Node* release_where_clause(); ::pg_query::Node* mutable_where_clause(); void set_allocated_where_clause(::pg_query::Node* where_clause); private: const ::pg_query::Node& _internal_where_clause() const; ::pg_query::Node* _internal_mutable_where_clause(); public: void unsafe_arena_set_allocated_where_clause( ::pg_query::Node* where_clause); ::pg_query::Node* unsafe_arena_release_where_clause(); // .pg_query.Node having_clause = 8 [json_name = "havingClause"]; bool has_having_clause() const; private: bool _internal_has_having_clause() const; public: void clear_having_clause(); const ::pg_query::Node& having_clause() const; PROTOBUF_NODISCARD ::pg_query::Node* release_having_clause(); ::pg_query::Node* mutable_having_clause(); void set_allocated_having_clause(::pg_query::Node* having_clause); private: const ::pg_query::Node& _internal_having_clause() const; ::pg_query::Node* _internal_mutable_having_clause(); public: void unsafe_arena_set_allocated_having_clause( ::pg_query::Node* having_clause); ::pg_query::Node* unsafe_arena_release_having_clause(); // .pg_query.Node limit_offset = 12 [json_name = "limitOffset"]; bool has_limit_offset() const; private: bool _internal_has_limit_offset() const; public: void clear_limit_offset(); const ::pg_query::Node& limit_offset() const; PROTOBUF_NODISCARD ::pg_query::Node* release_limit_offset(); ::pg_query::Node* mutable_limit_offset(); void set_allocated_limit_offset(::pg_query::Node* limit_offset); private: const ::pg_query::Node& _internal_limit_offset() const; ::pg_query::Node* _internal_mutable_limit_offset(); public: void unsafe_arena_set_allocated_limit_offset( ::pg_query::Node* limit_offset); ::pg_query::Node* unsafe_arena_release_limit_offset(); // .pg_query.Node limit_count = 13 [json_name = "limitCount"]; bool has_limit_count() const; private: bool _internal_has_limit_count() const; public: void clear_limit_count(); const ::pg_query::Node& limit_count() const; PROTOBUF_NODISCARD ::pg_query::Node* release_limit_count(); ::pg_query::Node* mutable_limit_count(); void set_allocated_limit_count(::pg_query::Node* limit_count); private: const ::pg_query::Node& _internal_limit_count() const; ::pg_query::Node* _internal_mutable_limit_count(); public: void unsafe_arena_set_allocated_limit_count( ::pg_query::Node* limit_count); ::pg_query::Node* unsafe_arena_release_limit_count(); // .pg_query.WithClause with_clause = 16 [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* with_clause); private: const ::pg_query::WithClause& _internal_with_clause() const; ::pg_query::WithClause* _internal_mutable_with_clause(); public: void unsafe_arena_set_allocated_with_clause( ::pg_query::WithClause* with_clause); ::pg_query::WithClause* unsafe_arena_release_with_clause(); // .pg_query.SelectStmt larg = 19 [json_name = "larg"]; bool has_larg() const; private: bool _internal_has_larg() const; public: 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* larg); private: const ::pg_query::SelectStmt& _internal_larg() const; ::pg_query::SelectStmt* _internal_mutable_larg(); public: void unsafe_arena_set_allocated_larg( ::pg_query::SelectStmt* larg); ::pg_query::SelectStmt* unsafe_arena_release_larg(); // .pg_query.SelectStmt rarg = 20 [json_name = "rarg"]; bool has_rarg() const; private: bool _internal_has_rarg() const; public: 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* rarg); private: const ::pg_query::SelectStmt& _internal_rarg() const; ::pg_query::SelectStmt* _internal_mutable_rarg(); public: void unsafe_arena_set_allocated_rarg( ::pg_query::SelectStmt* rarg); ::pg_query::SelectStmt* unsafe_arena_release_rarg(); // 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > distinct_clause_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > target_list_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > from_clause_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > group_clause_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > window_clause_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > values_lists_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > sort_clause_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > locking_clause_; ::pg_query::IntoClause* into_clause_; ::pg_query::Node* where_clause_; ::pg_query::Node* having_clause_; ::pg_query::Node* limit_offset_; ::pg_query::Node* limit_count_; ::pg_query::WithClause* with_clause_; ::pg_query::SelectStmt* larg_; ::pg_query::SelectStmt* rarg_; bool group_distinct_; bool all_; int limit_option_; int op_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class ReturnStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ReturnStmt) */ { public: inline ReturnStmt() : ReturnStmt(nullptr) {} ~ReturnStmt() override; explicit PROTOBUF_CONSTEXPR ReturnStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ReturnStmt(const ReturnStmt& 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 (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_ReturnStmt_default_instance_); } static constexpr int kIndexInFileMessages = 70; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ReturnStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ReturnStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ReturnStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ReturnStmt& from) { ReturnStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ReturnStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.ReturnStmt"; } protected: explicit ReturnStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kReturnvalFieldNumber = 1, }; // .pg_query.Node returnval = 1 [json_name = "returnval"]; bool has_returnval() const; private: bool _internal_has_returnval() const; public: 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* returnval); private: const ::pg_query::Node& _internal_returnval() const; ::pg_query::Node* _internal_mutable_returnval(); public: void unsafe_arena_set_allocated_returnval( ::pg_query::Node* returnval); ::pg_query::Node* unsafe_arena_release_returnval(); // @@protoc_insertion_point(class_scope:pg_query.ReturnStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::Node* returnval_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class PLAssignStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.PLAssignStmt) */ { public: inline PLAssignStmt() : PLAssignStmt(nullptr) {} ~PLAssignStmt() override; explicit PROTOBUF_CONSTEXPR PLAssignStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); PLAssignStmt(const PLAssignStmt& 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 (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_PLAssignStmt_default_instance_); } static constexpr int kIndexInFileMessages = 71; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PLAssignStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PLAssignStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const PLAssignStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const PLAssignStmt& from) { PLAssignStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(PLAssignStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.PLAssignStmt"; } protected: explicit PLAssignStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_indirection(); private: const ::pg_query::Node& _internal_indirection(int index) const; ::pg_query::Node* _internal_add_indirection(); public: const ::pg_query::Node& indirection(int index) const; ::pg_query::Node* add_indirection(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& indirection() const; // string name = 1 [json_name = "name"]; void clear_name(); const std::string& name() const; template void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); 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; private: bool _internal_has_val() const; public: 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* val); private: const ::pg_query::SelectStmt& _internal_val() const; ::pg_query::SelectStmt* _internal_mutable_val(); public: void unsafe_arena_set_allocated_val( ::pg_query::SelectStmt* val); ::pg_query::SelectStmt* unsafe_arena_release_val(); // 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > indirection_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; ::pg_query::SelectStmt* val_; int32_t nnames_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterTableStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterTableStmt) */ { public: inline AlterTableStmt() : AlterTableStmt(nullptr) {} ~AlterTableStmt() override; explicit PROTOBUF_CONSTEXPR AlterTableStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterTableStmt(const AlterTableStmt& from); AlterTableStmt(AlterTableStmt&& from) noexcept : AlterTableStmt() { *this = ::std::move(from); } inline AlterTableStmt& operator=(const AlterTableStmt& from) { CopyFrom(from); return *this; } inline AlterTableStmt& operator=(AlterTableStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterTableStmt_default_instance_); } static constexpr int kIndexInFileMessages = 72; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterTableStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterTableStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterTableStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterTableStmt& from) { AlterTableStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterTableStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterTableStmt"; } protected: explicit AlterTableStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_cmds(); private: const ::pg_query::Node& _internal_cmds(int index) const; ::pg_query::Node* _internal_add_cmds(); public: const ::pg_query::Node& cmds(int index) const; ::pg_query::Node* add_cmds(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& cmds() const; // .pg_query.RangeVar relation = 1 [json_name = "relation"]; bool has_relation() const; private: bool _internal_has_relation() const; public: void clear_relation(); const ::pg_query::RangeVar& relation() const; PROTOBUF_NODISCARD ::pg_query::RangeVar* release_relation(); ::pg_query::RangeVar* mutable_relation(); void set_allocated_relation(::pg_query::RangeVar* relation); private: const ::pg_query::RangeVar& _internal_relation() const; ::pg_query::RangeVar* _internal_mutable_relation(); public: void unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation); ::pg_query::RangeVar* unsafe_arena_release_relation(); // .pg_query.ObjectType 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > cmds_; ::pg_query::RangeVar* relation_; int objtype_; bool missing_ok_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterTableCmd final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterTableCmd) */ { public: inline AlterTableCmd() : AlterTableCmd(nullptr) {} ~AlterTableCmd() override; explicit PROTOBUF_CONSTEXPR AlterTableCmd(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterTableCmd(const AlterTableCmd& from); AlterTableCmd(AlterTableCmd&& from) noexcept : AlterTableCmd() { *this = ::std::move(from); } inline AlterTableCmd& operator=(const AlterTableCmd& from) { CopyFrom(from); return *this; } inline AlterTableCmd& operator=(AlterTableCmd&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterTableCmd_default_instance_); } static constexpr int kIndexInFileMessages = 73; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterTableCmd* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterTableCmd* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterTableCmd& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterTableCmd& from) { AlterTableCmd::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterTableCmd* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterTableCmd"; } protected: explicit AlterTableCmd(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); 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; private: bool _internal_has_newowner() const; public: 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* newowner); private: const ::pg_query::RoleSpec& _internal_newowner() const; ::pg_query::RoleSpec* _internal_mutable_newowner(); public: void unsafe_arena_set_allocated_newowner( ::pg_query::RoleSpec* newowner); ::pg_query::RoleSpec* unsafe_arena_release_newowner(); // .pg_query.Node def = 5 [json_name = "def"]; bool has_def() const; private: bool _internal_has_def() const; public: void clear_def(); const ::pg_query::Node& def() const; PROTOBUF_NODISCARD ::pg_query::Node* release_def(); ::pg_query::Node* mutable_def(); void set_allocated_def(::pg_query::Node* def); private: const ::pg_query::Node& _internal_def() const; ::pg_query::Node* _internal_mutable_def(); public: void unsafe_arena_set_allocated_def( ::pg_query::Node* def); ::pg_query::Node* unsafe_arena_release_def(); // .pg_query.AlterTableType subtype = 1 [json_name = "subtype"]; void clear_subtype(); ::pg_query::AlterTableType subtype() const; void set_subtype(::pg_query::AlterTableType value); private: ::pg_query::AlterTableType _internal_subtype() const; void _internal_set_subtype(::pg_query::AlterTableType value); public: // int32 num = 3 [json_name = "num"]; void clear_num(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; ::pg_query::RoleSpec* newowner_; ::pg_query::Node* def_; int subtype_; int32_t num_; int behavior_; bool missing_ok_; bool recurse_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterDomainStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterDomainStmt) */ { public: inline AlterDomainStmt() : AlterDomainStmt(nullptr) {} ~AlterDomainStmt() override; explicit PROTOBUF_CONSTEXPR AlterDomainStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterDomainStmt(const AlterDomainStmt& from); AlterDomainStmt(AlterDomainStmt&& from) noexcept : AlterDomainStmt() { *this = ::std::move(from); } inline AlterDomainStmt& operator=(const AlterDomainStmt& from) { CopyFrom(from); return *this; } inline AlterDomainStmt& operator=(AlterDomainStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterDomainStmt_default_instance_); } static constexpr int kIndexInFileMessages = 74; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterDomainStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterDomainStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterDomainStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterDomainStmt& from) { AlterDomainStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterDomainStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterDomainStmt"; } protected: explicit AlterDomainStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_type_name(); private: const ::pg_query::Node& _internal_type_name(int index) const; ::pg_query::Node* _internal_add_type_name(); public: const ::pg_query::Node& type_name(int index) const; ::pg_query::Node* add_type_name(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& type_name() const; // string subtype = 1 [json_name = "subtype"]; void clear_subtype(); const std::string& subtype() const; template void set_subtype(ArgT0&& arg0, ArgT... args); std::string* mutable_subtype(); PROTOBUF_NODISCARD std::string* release_subtype(); void set_allocated_subtype(std::string* subtype); 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 void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); 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; private: bool _internal_has_def() const; public: 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* def); private: const ::pg_query::Node& _internal_def() const; ::pg_query::Node* _internal_mutable_def(); public: void unsafe_arena_set_allocated_def( ::pg_query::Node* def); ::pg_query::Node* unsafe_arena_release_def(); // .pg_query.DropBehavior behavior = 5 [json_name = "behavior"]; void clear_behavior(); ::pg_query::DropBehavior behavior() const; void set_behavior(::pg_query::DropBehavior value); private: ::pg_query::DropBehavior _internal_behavior() const; void _internal_set_behavior(::pg_query::DropBehavior value); public: // bool missing_ok = 6 [json_name = "missing_ok"]; void clear_missing_ok(); bool missing_ok() const; void set_missing_ok(bool value); private: bool _internal_missing_ok() const; void _internal_set_missing_ok(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.AlterDomainStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > type_name_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr subtype_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; ::pg_query::Node* def_; int behavior_; bool missing_ok_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class SetOperationStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.SetOperationStmt) */ { public: inline SetOperationStmt() : SetOperationStmt(nullptr) {} ~SetOperationStmt() override; explicit PROTOBUF_CONSTEXPR SetOperationStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); SetOperationStmt(const SetOperationStmt& from); SetOperationStmt(SetOperationStmt&& from) noexcept : SetOperationStmt() { *this = ::std::move(from); } inline SetOperationStmt& operator=(const SetOperationStmt& from) { CopyFrom(from); return *this; } inline SetOperationStmt& operator=(SetOperationStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_SetOperationStmt_default_instance_); } static constexpr int kIndexInFileMessages = 75; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SetOperationStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- SetOperationStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const SetOperationStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const SetOperationStmt& from) { SetOperationStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(SetOperationStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.SetOperationStmt"; } protected: explicit SetOperationStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_col_types(); private: const ::pg_query::Node& _internal_col_types(int index) const; ::pg_query::Node* _internal_add_col_types(); public: const ::pg_query::Node& col_types(int index) const; ::pg_query::Node* add_col_types(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& col_types() const; // repeated .pg_query.Node col_typmods = 6 [json_name = "colTypmods"]; int col_typmods_size() const; private: int _internal_col_typmods_size() const; public: void clear_col_typmods(); ::pg_query::Node* mutable_col_typmods(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_col_typmods(); private: const ::pg_query::Node& _internal_col_typmods(int index) const; ::pg_query::Node* _internal_add_col_typmods(); public: const ::pg_query::Node& col_typmods(int index) const; ::pg_query::Node* add_col_typmods(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& col_typmods() const; // repeated .pg_query.Node col_collations = 7 [json_name = "colCollations"]; int col_collations_size() const; private: int _internal_col_collations_size() const; public: void clear_col_collations(); ::pg_query::Node* mutable_col_collations(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_col_collations(); private: const ::pg_query::Node& _internal_col_collations(int index) const; ::pg_query::Node* _internal_add_col_collations(); public: const ::pg_query::Node& col_collations(int index) const; ::pg_query::Node* add_col_collations(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& col_collations() const; // repeated .pg_query.Node group_clauses = 8 [json_name = "groupClauses"]; int group_clauses_size() const; private: int _internal_group_clauses_size() const; public: void clear_group_clauses(); ::pg_query::Node* mutable_group_clauses(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_group_clauses(); private: const ::pg_query::Node& _internal_group_clauses(int index) const; ::pg_query::Node* _internal_add_group_clauses(); public: const ::pg_query::Node& group_clauses(int index) const; ::pg_query::Node* add_group_clauses(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& group_clauses() const; // .pg_query.Node larg = 3 [json_name = "larg"]; bool has_larg() const; private: bool _internal_has_larg() const; public: void clear_larg(); const ::pg_query::Node& larg() const; PROTOBUF_NODISCARD ::pg_query::Node* release_larg(); ::pg_query::Node* mutable_larg(); void set_allocated_larg(::pg_query::Node* larg); private: const ::pg_query::Node& _internal_larg() const; ::pg_query::Node* _internal_mutable_larg(); public: void unsafe_arena_set_allocated_larg( ::pg_query::Node* larg); ::pg_query::Node* unsafe_arena_release_larg(); // .pg_query.Node rarg = 4 [json_name = "rarg"]; bool has_rarg() const; private: bool _internal_has_rarg() const; public: void clear_rarg(); const ::pg_query::Node& rarg() const; PROTOBUF_NODISCARD ::pg_query::Node* release_rarg(); ::pg_query::Node* mutable_rarg(); void set_allocated_rarg(::pg_query::Node* rarg); private: const ::pg_query::Node& _internal_rarg() const; ::pg_query::Node* _internal_mutable_rarg(); public: void unsafe_arena_set_allocated_rarg( ::pg_query::Node* rarg); ::pg_query::Node* unsafe_arena_release_rarg(); // .pg_query.SetOperation op = 1 [json_name = "op"]; void clear_op(); ::pg_query::SetOperation op() const; void set_op(::pg_query::SetOperation value); private: ::pg_query::SetOperation _internal_op() const; void _internal_set_op(::pg_query::SetOperation value); public: // bool all = 2 [json_name = "all"]; void clear_all(); bool all() const; void set_all(bool value); private: bool _internal_all() const; void _internal_set_all(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.SetOperationStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > col_types_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > col_typmods_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > col_collations_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > group_clauses_; ::pg_query::Node* larg_; ::pg_query::Node* rarg_; int op_; bool all_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class GrantStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.GrantStmt) */ { public: inline GrantStmt() : GrantStmt(nullptr) {} ~GrantStmt() override; explicit PROTOBUF_CONSTEXPR GrantStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); GrantStmt(const GrantStmt& from); GrantStmt(GrantStmt&& from) noexcept : GrantStmt() { *this = ::std::move(from); } inline GrantStmt& operator=(const GrantStmt& from) { CopyFrom(from); return *this; } inline GrantStmt& operator=(GrantStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_GrantStmt_default_instance_); } static constexpr int kIndexInFileMessages = 76; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(GrantStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- GrantStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const GrantStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const GrantStmt& from) { GrantStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(GrantStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.GrantStmt"; } protected: explicit GrantStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_objects(); private: const ::pg_query::Node& _internal_objects(int index) const; ::pg_query::Node* _internal_add_objects(); public: const ::pg_query::Node& objects(int index) const; ::pg_query::Node* add_objects(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& objects() const; // repeated .pg_query.Node privileges = 5 [json_name = "privileges"]; int privileges_size() const; private: int _internal_privileges_size() const; public: void clear_privileges(); ::pg_query::Node* mutable_privileges(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_privileges(); private: const ::pg_query::Node& _internal_privileges(int index) const; ::pg_query::Node* _internal_add_privileges(); public: const ::pg_query::Node& privileges(int index) const; ::pg_query::Node* add_privileges(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& privileges() const; // repeated .pg_query.Node grantees = 6 [json_name = "grantees"]; int grantees_size() const; private: int _internal_grantees_size() const; public: void clear_grantees(); ::pg_query::Node* mutable_grantees(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_grantees(); private: const ::pg_query::Node& _internal_grantees(int index) const; ::pg_query::Node* _internal_add_grantees(); public: const ::pg_query::Node& grantees(int index) const; ::pg_query::Node* add_grantees(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& grantees() const; // .pg_query.RoleSpec grantor = 8 [json_name = "grantor"]; bool has_grantor() const; private: bool _internal_has_grantor() const; public: 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* grantor); private: const ::pg_query::RoleSpec& _internal_grantor() const; ::pg_query::RoleSpec* _internal_mutable_grantor(); public: void unsafe_arena_set_allocated_grantor( ::pg_query::RoleSpec* grantor); ::pg_query::RoleSpec* unsafe_arena_release_grantor(); // .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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > objects_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > privileges_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > grantees_; ::pg_query::RoleSpec* grantor_; int targtype_; int objtype_; bool is_grant_; bool grant_option_; int behavior_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class GrantRoleStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.GrantRoleStmt) */ { public: inline GrantRoleStmt() : GrantRoleStmt(nullptr) {} ~GrantRoleStmt() override; explicit PROTOBUF_CONSTEXPR GrantRoleStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); GrantRoleStmt(const GrantRoleStmt& from); GrantRoleStmt(GrantRoleStmt&& from) noexcept : GrantRoleStmt() { *this = ::std::move(from); } inline GrantRoleStmt& operator=(const GrantRoleStmt& from) { CopyFrom(from); return *this; } inline GrantRoleStmt& operator=(GrantRoleStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_GrantRoleStmt_default_instance_); } static constexpr int kIndexInFileMessages = 77; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(GrantRoleStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- GrantRoleStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const GrantRoleStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const GrantRoleStmt& from) { GrantRoleStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(GrantRoleStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.GrantRoleStmt"; } protected: explicit GrantRoleStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kGrantedRolesFieldNumber = 1, kGranteeRolesFieldNumber = 2, kGrantorFieldNumber = 5, kIsGrantFieldNumber = 3, kAdminOptFieldNumber = 4, kBehaviorFieldNumber = 6, }; // repeated .pg_query.Node granted_roles = 1 [json_name = "granted_roles"]; int granted_roles_size() const; private: int _internal_granted_roles_size() const; public: void clear_granted_roles(); ::pg_query::Node* mutable_granted_roles(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_granted_roles(); private: const ::pg_query::Node& _internal_granted_roles(int index) const; ::pg_query::Node* _internal_add_granted_roles(); public: const ::pg_query::Node& granted_roles(int index) const; ::pg_query::Node* add_granted_roles(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& granted_roles() const; // repeated .pg_query.Node grantee_roles = 2 [json_name = "grantee_roles"]; int grantee_roles_size() const; private: int _internal_grantee_roles_size() const; public: void clear_grantee_roles(); ::pg_query::Node* mutable_grantee_roles(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_grantee_roles(); private: const ::pg_query::Node& _internal_grantee_roles(int index) const; ::pg_query::Node* _internal_add_grantee_roles(); public: const ::pg_query::Node& grantee_roles(int index) const; ::pg_query::Node* add_grantee_roles(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& grantee_roles() const; // .pg_query.RoleSpec grantor = 5 [json_name = "grantor"]; bool has_grantor() const; private: bool _internal_has_grantor() const; public: void clear_grantor(); const ::pg_query::RoleSpec& grantor() const; PROTOBUF_NODISCARD ::pg_query::RoleSpec* release_grantor(); ::pg_query::RoleSpec* mutable_grantor(); void set_allocated_grantor(::pg_query::RoleSpec* grantor); private: const ::pg_query::RoleSpec& _internal_grantor() const; ::pg_query::RoleSpec* _internal_mutable_grantor(); public: void unsafe_arena_set_allocated_grantor( ::pg_query::RoleSpec* grantor); ::pg_query::RoleSpec* unsafe_arena_release_grantor(); // bool is_grant = 3 [json_name = "is_grant"]; void clear_is_grant(); bool is_grant() const; void set_is_grant(bool value); private: bool _internal_is_grant() const; void _internal_set_is_grant(bool value); public: // bool admin_opt = 4 [json_name = "admin_opt"]; void clear_admin_opt(); bool admin_opt() const; void set_admin_opt(bool value); private: bool _internal_admin_opt() const; void _internal_set_admin_opt(bool value); public: // .pg_query.DropBehavior behavior = 6 [json_name = "behavior"]; void clear_behavior(); ::pg_query::DropBehavior behavior() const; void set_behavior(::pg_query::DropBehavior value); private: ::pg_query::DropBehavior _internal_behavior() const; void _internal_set_behavior(::pg_query::DropBehavior value); public: // @@protoc_insertion_point(class_scope:pg_query.GrantRoleStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > granted_roles_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > grantee_roles_; ::pg_query::RoleSpec* grantor_; bool is_grant_; bool admin_opt_; int behavior_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterDefaultPrivilegesStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterDefaultPrivilegesStmt) */ { public: inline AlterDefaultPrivilegesStmt() : AlterDefaultPrivilegesStmt(nullptr) {} ~AlterDefaultPrivilegesStmt() override; explicit PROTOBUF_CONSTEXPR AlterDefaultPrivilegesStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterDefaultPrivilegesStmt(const AlterDefaultPrivilegesStmt& from); AlterDefaultPrivilegesStmt(AlterDefaultPrivilegesStmt&& from) noexcept : AlterDefaultPrivilegesStmt() { *this = ::std::move(from); } inline AlterDefaultPrivilegesStmt& operator=(const AlterDefaultPrivilegesStmt& from) { CopyFrom(from); return *this; } inline AlterDefaultPrivilegesStmt& operator=(AlterDefaultPrivilegesStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterDefaultPrivilegesStmt_default_instance_); } static constexpr int kIndexInFileMessages = 78; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterDefaultPrivilegesStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterDefaultPrivilegesStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterDefaultPrivilegesStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterDefaultPrivilegesStmt& from) { AlterDefaultPrivilegesStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterDefaultPrivilegesStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterDefaultPrivilegesStmt"; } protected: explicit AlterDefaultPrivilegesStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // .pg_query.GrantStmt action = 2 [json_name = "action"]; bool has_action() const; private: bool _internal_has_action() const; public: void clear_action(); const ::pg_query::GrantStmt& action() const; PROTOBUF_NODISCARD ::pg_query::GrantStmt* release_action(); ::pg_query::GrantStmt* mutable_action(); void set_allocated_action(::pg_query::GrantStmt* action); private: const ::pg_query::GrantStmt& _internal_action() const; ::pg_query::GrantStmt* _internal_mutable_action(); public: void unsafe_arena_set_allocated_action( ::pg_query::GrantStmt* action); ::pg_query::GrantStmt* unsafe_arena_release_action(); // @@protoc_insertion_point(class_scope:pg_query.AlterDefaultPrivilegesStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::pg_query::GrantStmt* action_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class ClosePortalStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ClosePortalStmt) */ { public: inline ClosePortalStmt() : ClosePortalStmt(nullptr) {} ~ClosePortalStmt() override; explicit PROTOBUF_CONSTEXPR ClosePortalStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ClosePortalStmt(const ClosePortalStmt& from); ClosePortalStmt(ClosePortalStmt&& from) noexcept : ClosePortalStmt() { *this = ::std::move(from); } inline ClosePortalStmt& operator=(const ClosePortalStmt& from) { CopyFrom(from); return *this; } inline ClosePortalStmt& operator=(ClosePortalStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_ClosePortalStmt_default_instance_); } static constexpr int kIndexInFileMessages = 79; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ClosePortalStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ClosePortalStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ClosePortalStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ClosePortalStmt& from) { ClosePortalStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ClosePortalStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.ClosePortalStmt"; } protected: explicit ClosePortalStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_portalname(ArgT0&& arg0, ArgT... args); std::string* mutable_portalname(); PROTOBUF_NODISCARD std::string* release_portalname(); void set_allocated_portalname(std::string* portalname); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr portalname_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class ClusterStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ClusterStmt) */ { public: inline ClusterStmt() : ClusterStmt(nullptr) {} ~ClusterStmt() override; explicit PROTOBUF_CONSTEXPR ClusterStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ClusterStmt(const ClusterStmt& from); ClusterStmt(ClusterStmt&& from) noexcept : ClusterStmt() { *this = ::std::move(from); } inline ClusterStmt& operator=(const ClusterStmt& from) { CopyFrom(from); return *this; } inline ClusterStmt& operator=(ClusterStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_ClusterStmt_default_instance_); } static constexpr int kIndexInFileMessages = 80; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ClusterStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ClusterStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ClusterStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ClusterStmt& from) { ClusterStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ClusterStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.ClusterStmt"; } protected: explicit ClusterStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_params(); private: const ::pg_query::Node& _internal_params(int index) const; ::pg_query::Node* _internal_add_params(); public: const ::pg_query::Node& params(int index) const; ::pg_query::Node* add_params(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& params() const; // string indexname = 2 [json_name = "indexname"]; void clear_indexname(); const std::string& indexname() const; template void set_indexname(ArgT0&& arg0, ArgT... args); std::string* mutable_indexname(); PROTOBUF_NODISCARD std::string* release_indexname(); void set_allocated_indexname(std::string* indexname); 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; private: bool _internal_has_relation() const; public: 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* relation); private: const ::pg_query::RangeVar& _internal_relation() const; ::pg_query::RangeVar* _internal_mutable_relation(); public: void unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation); ::pg_query::RangeVar* unsafe_arena_release_relation(); // @@protoc_insertion_point(class_scope:pg_query.ClusterStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > params_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr indexname_; ::pg_query::RangeVar* relation_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CopyStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CopyStmt) */ { public: inline CopyStmt() : CopyStmt(nullptr) {} ~CopyStmt() override; explicit PROTOBUF_CONSTEXPR CopyStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CopyStmt(const CopyStmt& from); CopyStmt(CopyStmt&& from) noexcept : CopyStmt() { *this = ::std::move(from); } inline CopyStmt& operator=(const CopyStmt& from) { CopyFrom(from); return *this; } inline CopyStmt& operator=(CopyStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CopyStmt_default_instance_); } static constexpr int kIndexInFileMessages = 81; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CopyStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CopyStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CopyStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CopyStmt& from) { CopyStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CopyStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CopyStmt"; } protected: explicit CopyStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_attlist(); private: const ::pg_query::Node& _internal_attlist(int index) const; ::pg_query::Node* _internal_add_attlist(); public: const ::pg_query::Node& attlist(int index) const; ::pg_query::Node* add_attlist(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& attlist() const; // repeated .pg_query.Node options = 7 [json_name = "options"]; int options_size() const; private: int _internal_options_size() const; public: void clear_options(); ::pg_query::Node* mutable_options(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // string filename = 6 [json_name = "filename"]; void clear_filename(); const std::string& filename() const; template void set_filename(ArgT0&& arg0, ArgT... args); std::string* mutable_filename(); PROTOBUF_NODISCARD std::string* release_filename(); void set_allocated_filename(std::string* filename); 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; private: bool _internal_has_relation() const; public: 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* relation); private: const ::pg_query::RangeVar& _internal_relation() const; ::pg_query::RangeVar* _internal_mutable_relation(); public: void unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation); ::pg_query::RangeVar* unsafe_arena_release_relation(); // .pg_query.Node query = 2 [json_name = "query"]; bool has_query() const; private: bool _internal_has_query() const; public: void clear_query(); const ::pg_query::Node& query() const; PROTOBUF_NODISCARD ::pg_query::Node* release_query(); ::pg_query::Node* mutable_query(); void set_allocated_query(::pg_query::Node* query); private: const ::pg_query::Node& _internal_query() const; ::pg_query::Node* _internal_mutable_query(); public: void unsafe_arena_set_allocated_query( ::pg_query::Node* query); ::pg_query::Node* unsafe_arena_release_query(); // .pg_query.Node where_clause = 8 [json_name = "whereClause"]; bool has_where_clause() const; private: bool _internal_has_where_clause() const; public: void clear_where_clause(); const ::pg_query::Node& where_clause() const; PROTOBUF_NODISCARD ::pg_query::Node* release_where_clause(); ::pg_query::Node* mutable_where_clause(); void set_allocated_where_clause(::pg_query::Node* where_clause); private: const ::pg_query::Node& _internal_where_clause() const; ::pg_query::Node* _internal_mutable_where_clause(); public: void unsafe_arena_set_allocated_where_clause( ::pg_query::Node* where_clause); ::pg_query::Node* unsafe_arena_release_where_clause(); // bool is_from = 4 [json_name = "is_from"]; void clear_is_from(); bool is_from() const; void set_is_from(bool value); private: bool _internal_is_from() const; void _internal_set_is_from(bool value); public: // bool is_program = 5 [json_name = "is_program"]; void clear_is_program(); bool is_program() const; void set_is_program(bool value); private: bool _internal_is_program() const; void _internal_set_is_program(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.CopyStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > attlist_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filename_; ::pg_query::RangeVar* relation_; ::pg_query::Node* query_; ::pg_query::Node* where_clause_; bool is_from_; bool is_program_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreateStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateStmt) */ { public: inline CreateStmt() : CreateStmt(nullptr) {} ~CreateStmt() override; explicit PROTOBUF_CONSTEXPR CreateStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreateStmt(const CreateStmt& from); CreateStmt(CreateStmt&& from) noexcept : CreateStmt() { *this = ::std::move(from); } inline CreateStmt& operator=(const CreateStmt& from) { CopyFrom(from); return *this; } inline CreateStmt& operator=(CreateStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreateStmt_default_instance_); } static constexpr int kIndexInFileMessages = 82; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreateStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreateStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreateStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreateStmt& from) { CreateStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreateStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreateStmt"; } protected: explicit CreateStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_table_elts(); private: const ::pg_query::Node& _internal_table_elts(int index) const; ::pg_query::Node* _internal_add_table_elts(); public: const ::pg_query::Node& table_elts(int index) const; ::pg_query::Node* add_table_elts(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& table_elts() const; // repeated .pg_query.Node inh_relations = 3 [json_name = "inhRelations"]; int inh_relations_size() const; private: int _internal_inh_relations_size() const; public: void clear_inh_relations(); ::pg_query::Node* mutable_inh_relations(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_inh_relations(); private: const ::pg_query::Node& _internal_inh_relations(int index) const; ::pg_query::Node* _internal_add_inh_relations(); public: const ::pg_query::Node& inh_relations(int index) const; ::pg_query::Node* add_inh_relations(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& inh_relations() const; // repeated .pg_query.Node constraints = 7 [json_name = "constraints"]; int constraints_size() const; private: int _internal_constraints_size() const; public: void clear_constraints(); ::pg_query::Node* mutable_constraints(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_constraints(); private: const ::pg_query::Node& _internal_constraints(int index) const; ::pg_query::Node* _internal_add_constraints(); public: const ::pg_query::Node& constraints(int index) const; ::pg_query::Node* add_constraints(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& constraints() const; // repeated .pg_query.Node options = 8 [json_name = "options"]; int options_size() const; private: int _internal_options_size() const; public: void clear_options(); ::pg_query::Node* mutable_options(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // string tablespacename = 10 [json_name = "tablespacename"]; void clear_tablespacename(); const std::string& tablespacename() const; template void set_tablespacename(ArgT0&& arg0, ArgT... args); std::string* mutable_tablespacename(); PROTOBUF_NODISCARD std::string* release_tablespacename(); void set_allocated_tablespacename(std::string* tablespacename); 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 void set_access_method(ArgT0&& arg0, ArgT... args); std::string* mutable_access_method(); PROTOBUF_NODISCARD std::string* release_access_method(); void set_allocated_access_method(std::string* access_method); 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; private: bool _internal_has_relation() const; public: 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* relation); private: const ::pg_query::RangeVar& _internal_relation() const; ::pg_query::RangeVar* _internal_mutable_relation(); public: void unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation); ::pg_query::RangeVar* unsafe_arena_release_relation(); // .pg_query.PartitionBoundSpec partbound = 4 [json_name = "partbound"]; bool has_partbound() const; private: bool _internal_has_partbound() const; public: void clear_partbound(); const ::pg_query::PartitionBoundSpec& partbound() const; PROTOBUF_NODISCARD ::pg_query::PartitionBoundSpec* release_partbound(); ::pg_query::PartitionBoundSpec* mutable_partbound(); void set_allocated_partbound(::pg_query::PartitionBoundSpec* partbound); private: const ::pg_query::PartitionBoundSpec& _internal_partbound() const; ::pg_query::PartitionBoundSpec* _internal_mutable_partbound(); public: void unsafe_arena_set_allocated_partbound( ::pg_query::PartitionBoundSpec* partbound); ::pg_query::PartitionBoundSpec* unsafe_arena_release_partbound(); // .pg_query.PartitionSpec partspec = 5 [json_name = "partspec"]; bool has_partspec() const; private: bool _internal_has_partspec() const; public: void clear_partspec(); const ::pg_query::PartitionSpec& partspec() const; PROTOBUF_NODISCARD ::pg_query::PartitionSpec* release_partspec(); ::pg_query::PartitionSpec* mutable_partspec(); void set_allocated_partspec(::pg_query::PartitionSpec* partspec); private: const ::pg_query::PartitionSpec& _internal_partspec() const; ::pg_query::PartitionSpec* _internal_mutable_partspec(); public: void unsafe_arena_set_allocated_partspec( ::pg_query::PartitionSpec* partspec); ::pg_query::PartitionSpec* unsafe_arena_release_partspec(); // .pg_query.TypeName of_typename = 6 [json_name = "ofTypename"]; bool has_of_typename() const; private: bool _internal_has_of_typename() const; public: void clear_of_typename(); const ::pg_query::TypeName& of_typename() const; PROTOBUF_NODISCARD ::pg_query::TypeName* release_of_typename(); ::pg_query::TypeName* mutable_of_typename(); void set_allocated_of_typename(::pg_query::TypeName* of_typename); private: const ::pg_query::TypeName& _internal_of_typename() const; ::pg_query::TypeName* _internal_mutable_of_typename(); public: void unsafe_arena_set_allocated_of_typename( ::pg_query::TypeName* of_typename); ::pg_query::TypeName* unsafe_arena_release_of_typename(); // .pg_query.OnCommitAction oncommit = 9 [json_name = "oncommit"]; void clear_oncommit(); ::pg_query::OnCommitAction oncommit() const; void set_oncommit(::pg_query::OnCommitAction value); private: ::pg_query::OnCommitAction _internal_oncommit() const; void _internal_set_oncommit(::pg_query::OnCommitAction value); public: // bool if_not_exists = 12 [json_name = "if_not_exists"]; void clear_if_not_exists(); bool if_not_exists() const; void set_if_not_exists(bool value); private: bool _internal_if_not_exists() const; void _internal_set_if_not_exists(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.CreateStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > table_elts_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > inh_relations_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > constraints_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tablespacename_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr access_method_; ::pg_query::RangeVar* relation_; ::pg_query::PartitionBoundSpec* partbound_; ::pg_query::PartitionSpec* partspec_; ::pg_query::TypeName* of_typename_; int oncommit_; bool if_not_exists_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class DefineStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DefineStmt) */ { public: inline DefineStmt() : DefineStmt(nullptr) {} ~DefineStmt() override; explicit PROTOBUF_CONSTEXPR DefineStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); DefineStmt(const DefineStmt& from); DefineStmt(DefineStmt&& from) noexcept : DefineStmt() { *this = ::std::move(from); } inline DefineStmt& operator=(const DefineStmt& from) { CopyFrom(from); return *this; } inline DefineStmt& operator=(DefineStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_DefineStmt_default_instance_); } static constexpr int kIndexInFileMessages = 83; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(DefineStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- DefineStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DefineStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const DefineStmt& from) { DefineStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DefineStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.DefineStmt"; } protected: explicit DefineStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_defnames(); private: const ::pg_query::Node& _internal_defnames(int index) const; ::pg_query::Node* _internal_add_defnames(); public: const ::pg_query::Node& defnames(int index) const; ::pg_query::Node* add_defnames(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& defnames() const; // repeated .pg_query.Node args = 4 [json_name = "args"]; int args_size() const; private: int _internal_args_size() const; public: void clear_args(); ::pg_query::Node* mutable_args(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_args(); private: const ::pg_query::Node& _internal_args(int index) const; ::pg_query::Node* _internal_add_args(); public: const ::pg_query::Node& args(int index) const; ::pg_query::Node* add_args(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& args() const; // repeated .pg_query.Node definition = 5 [json_name = "definition"]; int definition_size() const; private: int _internal_definition_size() const; public: void clear_definition(); ::pg_query::Node* mutable_definition(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_definition(); private: const ::pg_query::Node& _internal_definition(int index) const; ::pg_query::Node* _internal_add_definition(); public: const ::pg_query::Node& definition(int index) const; ::pg_query::Node* add_definition(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& definition() const; // .pg_query.ObjectType kind = 1 [json_name = "kind"]; void clear_kind(); ::pg_query::ObjectType kind() const; void set_kind(::pg_query::ObjectType value); private: ::pg_query::ObjectType _internal_kind() const; void _internal_set_kind(::pg_query::ObjectType value); public: // bool oldstyle = 2 [json_name = "oldstyle"]; void clear_oldstyle(); bool oldstyle() const; void set_oldstyle(bool value); private: bool _internal_oldstyle() const; void _internal_set_oldstyle(bool value); public: // bool if_not_exists = 6 [json_name = "if_not_exists"]; void clear_if_not_exists(); bool if_not_exists() const; void set_if_not_exists(bool value); private: bool _internal_if_not_exists() const; void _internal_set_if_not_exists(bool value); public: // bool replace = 7 [json_name = "replace"]; void clear_replace(); bool replace() const; void set_replace(bool value); private: bool _internal_replace() const; void _internal_set_replace(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.DefineStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > defnames_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > definition_; int kind_; bool oldstyle_; bool if_not_exists_; bool replace_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class DropStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DropStmt) */ { public: inline DropStmt() : DropStmt(nullptr) {} ~DropStmt() override; explicit PROTOBUF_CONSTEXPR DropStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); DropStmt(const DropStmt& from); DropStmt(DropStmt&& from) noexcept : DropStmt() { *this = ::std::move(from); } inline DropStmt& operator=(const DropStmt& from) { CopyFrom(from); return *this; } inline DropStmt& operator=(DropStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_DropStmt_default_instance_); } static constexpr int kIndexInFileMessages = 84; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(DropStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- DropStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DropStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const DropStmt& from) { DropStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DropStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.DropStmt"; } protected: explicit DropStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_objects(); private: const ::pg_query::Node& _internal_objects(int index) const; ::pg_query::Node* _internal_add_objects(); public: const ::pg_query::Node& objects(int index) const; ::pg_query::Node* add_objects(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& objects() const; // .pg_query.ObjectType remove_type = 2 [json_name = "removeType"]; void clear_remove_type(); ::pg_query::ObjectType remove_type() const; void set_remove_type(::pg_query::ObjectType value); private: ::pg_query::ObjectType _internal_remove_type() const; void _internal_set_remove_type(::pg_query::ObjectType value); public: // .pg_query.DropBehavior behavior = 3 [json_name = "behavior"]; void clear_behavior(); ::pg_query::DropBehavior behavior() const; void set_behavior(::pg_query::DropBehavior value); private: ::pg_query::DropBehavior _internal_behavior() const; void _internal_set_behavior(::pg_query::DropBehavior value); public: // bool missing_ok = 4 [json_name = "missing_ok"]; void clear_missing_ok(); bool missing_ok() const; void set_missing_ok(bool value); private: bool _internal_missing_ok() const; void _internal_set_missing_ok(bool value); public: // bool concurrent = 5 [json_name = "concurrent"]; void clear_concurrent(); bool concurrent() const; void set_concurrent(bool value); private: bool _internal_concurrent() const; void _internal_set_concurrent(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.DropStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > objects_; int remove_type_; int behavior_; bool missing_ok_; bool concurrent_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class TruncateStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.TruncateStmt) */ { public: inline TruncateStmt() : TruncateStmt(nullptr) {} ~TruncateStmt() override; explicit PROTOBUF_CONSTEXPR TruncateStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); TruncateStmt(const TruncateStmt& from); TruncateStmt(TruncateStmt&& from) noexcept : TruncateStmt() { *this = ::std::move(from); } inline TruncateStmt& operator=(const TruncateStmt& from) { CopyFrom(from); return *this; } inline TruncateStmt& operator=(TruncateStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_TruncateStmt_default_instance_); } static constexpr int kIndexInFileMessages = 85; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(TruncateStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- TruncateStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const TruncateStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const TruncateStmt& from) { TruncateStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(TruncateStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.TruncateStmt"; } protected: explicit TruncateStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_relations(); private: const ::pg_query::Node& _internal_relations(int index) const; ::pg_query::Node* _internal_add_relations(); public: const ::pg_query::Node& relations(int index) const; ::pg_query::Node* add_relations(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& relations() const; // bool restart_seqs = 2 [json_name = "restart_seqs"]; void clear_restart_seqs(); bool restart_seqs() const; void set_restart_seqs(bool value); private: bool _internal_restart_seqs() const; void _internal_set_restart_seqs(bool value); public: // .pg_query.DropBehavior behavior = 3 [json_name = "behavior"]; void clear_behavior(); ::pg_query::DropBehavior behavior() const; void set_behavior(::pg_query::DropBehavior value); private: ::pg_query::DropBehavior _internal_behavior() const; void _internal_set_behavior(::pg_query::DropBehavior value); public: // @@protoc_insertion_point(class_scope:pg_query.TruncateStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > relations_; bool restart_seqs_; int behavior_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CommentStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CommentStmt) */ { public: inline CommentStmt() : CommentStmt(nullptr) {} ~CommentStmt() override; explicit PROTOBUF_CONSTEXPR CommentStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CommentStmt(const CommentStmt& from); CommentStmt(CommentStmt&& from) noexcept : CommentStmt() { *this = ::std::move(from); } inline CommentStmt& operator=(const CommentStmt& from) { CopyFrom(from); return *this; } inline CommentStmt& operator=(CommentStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CommentStmt_default_instance_); } static constexpr int kIndexInFileMessages = 86; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CommentStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CommentStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CommentStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CommentStmt& from) { CommentStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CommentStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CommentStmt"; } protected: explicit CommentStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_comment(ArgT0&& arg0, ArgT... args); std::string* mutable_comment(); PROTOBUF_NODISCARD std::string* release_comment(); void set_allocated_comment(std::string* comment); 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; private: bool _internal_has_object() const; public: 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* object); private: const ::pg_query::Node& _internal_object() const; ::pg_query::Node* _internal_mutable_object(); public: void unsafe_arena_set_allocated_object( ::pg_query::Node* object); ::pg_query::Node* unsafe_arena_release_object(); // .pg_query.ObjectType objtype = 1 [json_name = "objtype"]; void clear_objtype(); ::pg_query::ObjectType objtype() const; void set_objtype(::pg_query::ObjectType value); private: ::pg_query::ObjectType _internal_objtype() const; void _internal_set_objtype(::pg_query::ObjectType value); public: // @@protoc_insertion_point(class_scope:pg_query.CommentStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr comment_; ::pg_query::Node* object_; int objtype_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class FetchStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.FetchStmt) */ { public: inline FetchStmt() : FetchStmt(nullptr) {} ~FetchStmt() override; explicit PROTOBUF_CONSTEXPR FetchStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); FetchStmt(const FetchStmt& from); FetchStmt(FetchStmt&& from) noexcept : FetchStmt() { *this = ::std::move(from); } inline FetchStmt& operator=(const FetchStmt& from) { CopyFrom(from); return *this; } inline FetchStmt& operator=(FetchStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_FetchStmt_default_instance_); } static constexpr int kIndexInFileMessages = 87; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(FetchStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- FetchStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const FetchStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const FetchStmt& from) { FetchStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(FetchStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.FetchStmt"; } protected: explicit FetchStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_portalname(ArgT0&& arg0, ArgT... args); std::string* mutable_portalname(); PROTOBUF_NODISCARD std::string* release_portalname(); void set_allocated_portalname(std::string* portalname); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr portalname_; int64_t how_many_; int direction_; bool ismove_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class IndexStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.IndexStmt) */ { public: inline IndexStmt() : IndexStmt(nullptr) {} ~IndexStmt() override; explicit PROTOBUF_CONSTEXPR IndexStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); IndexStmt(const IndexStmt& from); IndexStmt(IndexStmt&& from) noexcept : IndexStmt() { *this = ::std::move(from); } inline IndexStmt& operator=(const IndexStmt& from) { CopyFrom(from); return *this; } inline IndexStmt& operator=(IndexStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_IndexStmt_default_instance_); } static constexpr int kIndexInFileMessages = 88; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(IndexStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- IndexStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const IndexStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const IndexStmt& from) { IndexStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(IndexStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.IndexStmt"; } protected: explicit IndexStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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, kOldNodeFieldNumber = 12, kOldCreateSubidFieldNumber = 13, kOldFirstRelfilenodeSubidFieldNumber = 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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_index_params(); private: const ::pg_query::Node& _internal_index_params(int index) const; ::pg_query::Node* _internal_add_index_params(); public: const ::pg_query::Node& index_params(int index) const; ::pg_query::Node* add_index_params(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& index_params() const; // repeated .pg_query.Node index_including_params = 6 [json_name = "indexIncludingParams"]; int index_including_params_size() const; private: int _internal_index_including_params_size() const; public: void clear_index_including_params(); ::pg_query::Node* mutable_index_including_params(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_index_including_params(); private: const ::pg_query::Node& _internal_index_including_params(int index) const; ::pg_query::Node* _internal_add_index_including_params(); public: const ::pg_query::Node& index_including_params(int index) const; ::pg_query::Node* add_index_including_params(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& index_including_params() const; // repeated .pg_query.Node options = 7 [json_name = "options"]; int options_size() const; private: int _internal_options_size() const; public: void clear_options(); ::pg_query::Node* mutable_options(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // repeated .pg_query.Node exclude_op_names = 9 [json_name = "excludeOpNames"]; int exclude_op_names_size() const; private: int _internal_exclude_op_names_size() const; public: void clear_exclude_op_names(); ::pg_query::Node* mutable_exclude_op_names(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_exclude_op_names(); private: const ::pg_query::Node& _internal_exclude_op_names(int index) const; ::pg_query::Node* _internal_add_exclude_op_names(); public: const ::pg_query::Node& exclude_op_names(int index) const; ::pg_query::Node* add_exclude_op_names(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& exclude_op_names() const; // string idxname = 1 [json_name = "idxname"]; void clear_idxname(); const std::string& idxname() const; template void set_idxname(ArgT0&& arg0, ArgT... args); std::string* mutable_idxname(); PROTOBUF_NODISCARD std::string* release_idxname(); void set_allocated_idxname(std::string* idxname); 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 void set_access_method(ArgT0&& arg0, ArgT... args); std::string* mutable_access_method(); PROTOBUF_NODISCARD std::string* release_access_method(); void set_allocated_access_method(std::string* access_method); 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 void set_table_space(ArgT0&& arg0, ArgT... args); std::string* mutable_table_space(); PROTOBUF_NODISCARD std::string* release_table_space(); void set_allocated_table_space(std::string* table_space); 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 void set_idxcomment(ArgT0&& arg0, ArgT... args); std::string* mutable_idxcomment(); PROTOBUF_NODISCARD std::string* release_idxcomment(); void set_allocated_idxcomment(std::string* idxcomment); 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; private: bool _internal_has_relation() const; public: 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* relation); private: const ::pg_query::RangeVar& _internal_relation() const; ::pg_query::RangeVar* _internal_mutable_relation(); public: void unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation); ::pg_query::RangeVar* unsafe_arena_release_relation(); // .pg_query.Node where_clause = 8 [json_name = "whereClause"]; bool has_where_clause() const; private: bool _internal_has_where_clause() const; public: void clear_where_clause(); const ::pg_query::Node& where_clause() const; PROTOBUF_NODISCARD ::pg_query::Node* release_where_clause(); ::pg_query::Node* mutable_where_clause(); void set_allocated_where_clause(::pg_query::Node* where_clause); private: const ::pg_query::Node& _internal_where_clause() const; ::pg_query::Node* _internal_mutable_where_clause(); public: void unsafe_arena_set_allocated_where_clause( ::pg_query::Node* where_clause); ::pg_query::Node* unsafe_arena_release_where_clause(); // uint32 index_oid = 11 [json_name = "indexOid"]; void clear_index_oid(); 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_node = 12 [json_name = "oldNode"]; void clear_old_node(); uint32_t old_node() const; void set_old_node(uint32_t value); private: uint32_t _internal_old_node() const; void _internal_set_old_node(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_relfilenode_subid = 14 [json_name = "oldFirstRelfilenodeSubid"]; void clear_old_first_relfilenode_subid(); uint32_t old_first_relfilenode_subid() const; void set_old_first_relfilenode_subid(uint32_t value); private: uint32_t _internal_old_first_relfilenode_subid() const; void _internal_set_old_first_relfilenode_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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > index_params_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > index_including_params_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > exclude_op_names_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr idxname_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr access_method_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_space_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr idxcomment_; ::pg_query::RangeVar* relation_; ::pg_query::Node* where_clause_; uint32_t index_oid_; uint32_t old_node_; uint32_t old_create_subid_; uint32_t old_first_relfilenode_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_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreateFunctionStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateFunctionStmt) */ { public: inline CreateFunctionStmt() : CreateFunctionStmt(nullptr) {} ~CreateFunctionStmt() override; explicit PROTOBUF_CONSTEXPR CreateFunctionStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreateFunctionStmt(const CreateFunctionStmt& from); CreateFunctionStmt(CreateFunctionStmt&& from) noexcept : CreateFunctionStmt() { *this = ::std::move(from); } inline CreateFunctionStmt& operator=(const CreateFunctionStmt& from) { CopyFrom(from); return *this; } inline CreateFunctionStmt& operator=(CreateFunctionStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreateFunctionStmt_default_instance_); } static constexpr int kIndexInFileMessages = 89; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreateFunctionStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreateFunctionStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreateFunctionStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreateFunctionStmt& from) { CreateFunctionStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreateFunctionStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreateFunctionStmt"; } protected: explicit CreateFunctionStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_funcname(); private: const ::pg_query::Node& _internal_funcname(int index) const; ::pg_query::Node* _internal_add_funcname(); public: const ::pg_query::Node& funcname(int index) const; ::pg_query::Node* add_funcname(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& funcname() const; // repeated .pg_query.Node parameters = 4 [json_name = "parameters"]; int parameters_size() const; private: int _internal_parameters_size() const; public: void clear_parameters(); ::pg_query::Node* mutable_parameters(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_parameters(); private: const ::pg_query::Node& _internal_parameters(int index) const; ::pg_query::Node* _internal_add_parameters(); public: const ::pg_query::Node& parameters(int index) const; ::pg_query::Node* add_parameters(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& parameters() const; // repeated .pg_query.Node options = 6 [json_name = "options"]; int options_size() const; private: int _internal_options_size() const; public: void clear_options(); ::pg_query::Node* mutable_options(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // .pg_query.TypeName return_type = 5 [json_name = "returnType"]; bool has_return_type() const; private: bool _internal_has_return_type() const; public: void clear_return_type(); const ::pg_query::TypeName& return_type() const; PROTOBUF_NODISCARD ::pg_query::TypeName* release_return_type(); ::pg_query::TypeName* mutable_return_type(); void set_allocated_return_type(::pg_query::TypeName* return_type); private: const ::pg_query::TypeName& _internal_return_type() const; ::pg_query::TypeName* _internal_mutable_return_type(); public: void unsafe_arena_set_allocated_return_type( ::pg_query::TypeName* return_type); ::pg_query::TypeName* unsafe_arena_release_return_type(); // .pg_query.Node sql_body = 7 [json_name = "sql_body"]; bool has_sql_body() const; private: bool _internal_has_sql_body() const; public: 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* sql_body); private: const ::pg_query::Node& _internal_sql_body() const; ::pg_query::Node* _internal_mutable_sql_body(); public: void unsafe_arena_set_allocated_sql_body( ::pg_query::Node* sql_body); ::pg_query::Node* unsafe_arena_release_sql_body(); // bool is_procedure = 1 [json_name = "is_procedure"]; void clear_is_procedure(); bool is_procedure() const; void set_is_procedure(bool value); private: bool _internal_is_procedure() const; void _internal_set_is_procedure(bool value); public: // bool replace = 2 [json_name = "replace"]; void clear_replace(); bool replace() const; void set_replace(bool value); private: bool _internal_replace() const; void _internal_set_replace(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.CreateFunctionStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > funcname_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > parameters_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::pg_query::TypeName* return_type_; ::pg_query::Node* sql_body_; bool is_procedure_; bool replace_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterFunctionStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterFunctionStmt) */ { public: inline AlterFunctionStmt() : AlterFunctionStmt(nullptr) {} ~AlterFunctionStmt() override; explicit PROTOBUF_CONSTEXPR AlterFunctionStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterFunctionStmt(const AlterFunctionStmt& from); AlterFunctionStmt(AlterFunctionStmt&& from) noexcept : AlterFunctionStmt() { *this = ::std::move(from); } inline AlterFunctionStmt& operator=(const AlterFunctionStmt& from) { CopyFrom(from); return *this; } inline AlterFunctionStmt& operator=(AlterFunctionStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterFunctionStmt_default_instance_); } static constexpr int kIndexInFileMessages = 90; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterFunctionStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterFunctionStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterFunctionStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterFunctionStmt& from) { AlterFunctionStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterFunctionStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterFunctionStmt"; } protected: explicit AlterFunctionStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_actions(); private: const ::pg_query::Node& _internal_actions(int index) const; ::pg_query::Node* _internal_add_actions(); public: const ::pg_query::Node& actions(int index) const; ::pg_query::Node* add_actions(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& actions() const; // .pg_query.ObjectWithArgs func = 2 [json_name = "func"]; bool has_func() const; private: bool _internal_has_func() const; public: void clear_func(); const ::pg_query::ObjectWithArgs& func() const; PROTOBUF_NODISCARD ::pg_query::ObjectWithArgs* release_func(); ::pg_query::ObjectWithArgs* mutable_func(); void set_allocated_func(::pg_query::ObjectWithArgs* func); private: const ::pg_query::ObjectWithArgs& _internal_func() const; ::pg_query::ObjectWithArgs* _internal_mutable_func(); public: void unsafe_arena_set_allocated_func( ::pg_query::ObjectWithArgs* func); ::pg_query::ObjectWithArgs* unsafe_arena_release_func(); // .pg_query.ObjectType objtype = 1 [json_name = "objtype"]; void clear_objtype(); ::pg_query::ObjectType objtype() const; void set_objtype(::pg_query::ObjectType value); private: ::pg_query::ObjectType _internal_objtype() const; void _internal_set_objtype(::pg_query::ObjectType value); public: // @@protoc_insertion_point(class_scope:pg_query.AlterFunctionStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > actions_; ::pg_query::ObjectWithArgs* func_; int objtype_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class DoStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DoStmt) */ { public: inline DoStmt() : DoStmt(nullptr) {} ~DoStmt() override; explicit PROTOBUF_CONSTEXPR DoStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); DoStmt(const DoStmt& from); DoStmt(DoStmt&& from) noexcept : DoStmt() { *this = ::std::move(from); } inline DoStmt& operator=(const DoStmt& from) { CopyFrom(from); return *this; } inline DoStmt& operator=(DoStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_DoStmt_default_instance_); } static constexpr int kIndexInFileMessages = 91; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(DoStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- DoStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DoStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const DoStmt& from) { DoStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DoStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.DoStmt"; } protected: explicit DoStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_args(); private: const ::pg_query::Node& _internal_args(int index) const; ::pg_query::Node* _internal_add_args(); public: const ::pg_query::Node& args(int index) const; ::pg_query::Node* add_args(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& args() const; // @@protoc_insertion_point(class_scope:pg_query.DoStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class RenameStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RenameStmt) */ { public: inline RenameStmt() : RenameStmt(nullptr) {} ~RenameStmt() override; explicit PROTOBUF_CONSTEXPR RenameStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); RenameStmt(const RenameStmt& from); RenameStmt(RenameStmt&& from) noexcept : RenameStmt() { *this = ::std::move(from); } inline RenameStmt& operator=(const RenameStmt& from) { CopyFrom(from); return *this; } inline RenameStmt& operator=(RenameStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_RenameStmt_default_instance_); } static constexpr int kIndexInFileMessages = 92; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(RenameStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- RenameStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const RenameStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const RenameStmt& from) { RenameStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(RenameStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.RenameStmt"; } protected: explicit RenameStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_subname(ArgT0&& arg0, ArgT... args); std::string* mutable_subname(); PROTOBUF_NODISCARD std::string* release_subname(); void set_allocated_subname(std::string* subname); 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 void set_newname(ArgT0&& arg0, ArgT... args); std::string* mutable_newname(); PROTOBUF_NODISCARD std::string* release_newname(); void set_allocated_newname(std::string* newname); 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; private: bool _internal_has_relation() const; public: 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* relation); private: const ::pg_query::RangeVar& _internal_relation() const; ::pg_query::RangeVar* _internal_mutable_relation(); public: void unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation); ::pg_query::RangeVar* unsafe_arena_release_relation(); // .pg_query.Node object = 4 [json_name = "object"]; bool has_object() const; private: bool _internal_has_object() const; public: void clear_object(); const ::pg_query::Node& object() const; PROTOBUF_NODISCARD ::pg_query::Node* release_object(); ::pg_query::Node* mutable_object(); void set_allocated_object(::pg_query::Node* object); private: const ::pg_query::Node& _internal_object() const; ::pg_query::Node* _internal_mutable_object(); public: void unsafe_arena_set_allocated_object( ::pg_query::Node* object); ::pg_query::Node* unsafe_arena_release_object(); // .pg_query.ObjectType rename_type = 1 [json_name = "renameType"]; void clear_rename_type(); ::pg_query::ObjectType rename_type() const; void set_rename_type(::pg_query::ObjectType value); private: ::pg_query::ObjectType _internal_rename_type() const; void _internal_set_rename_type(::pg_query::ObjectType value); public: // .pg_query.ObjectType relation_type = 2 [json_name = "relationType"]; void clear_relation_type(); ::pg_query::ObjectType relation_type() const; void set_relation_type(::pg_query::ObjectType value); private: ::pg_query::ObjectType _internal_relation_type() const; void _internal_set_relation_type(::pg_query::ObjectType value); public: // .pg_query.DropBehavior behavior = 7 [json_name = "behavior"]; void clear_behavior(); ::pg_query::DropBehavior behavior() const; void set_behavior(::pg_query::DropBehavior value); private: ::pg_query::DropBehavior _internal_behavior() const; void _internal_set_behavior(::pg_query::DropBehavior value); public: // bool missing_ok = 8 [json_name = "missing_ok"]; void clear_missing_ok(); bool missing_ok() const; void set_missing_ok(bool value); private: bool _internal_missing_ok() const; void _internal_set_missing_ok(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.RenameStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr subname_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr newname_; ::pg_query::RangeVar* relation_; ::pg_query::Node* object_; int rename_type_; int relation_type_; int behavior_; bool missing_ok_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class RuleStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RuleStmt) */ { public: inline RuleStmt() : RuleStmt(nullptr) {} ~RuleStmt() override; explicit PROTOBUF_CONSTEXPR RuleStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); RuleStmt(const RuleStmt& from); RuleStmt(RuleStmt&& from) noexcept : RuleStmt() { *this = ::std::move(from); } inline RuleStmt& operator=(const RuleStmt& from) { CopyFrom(from); return *this; } inline RuleStmt& operator=(RuleStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_RuleStmt_default_instance_); } static constexpr int kIndexInFileMessages = 93; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(RuleStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- RuleStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const RuleStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const RuleStmt& from) { RuleStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(RuleStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.RuleStmt"; } protected: explicit RuleStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_actions(); private: const ::pg_query::Node& _internal_actions(int index) const; ::pg_query::Node* _internal_add_actions(); public: const ::pg_query::Node& actions(int index) const; ::pg_query::Node* add_actions(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& actions() const; // string rulename = 2 [json_name = "rulename"]; void clear_rulename(); const std::string& rulename() const; template void set_rulename(ArgT0&& arg0, ArgT... args); std::string* mutable_rulename(); PROTOBUF_NODISCARD std::string* release_rulename(); void set_allocated_rulename(std::string* rulename); 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; private: bool _internal_has_relation() const; public: 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* relation); private: const ::pg_query::RangeVar& _internal_relation() const; ::pg_query::RangeVar* _internal_mutable_relation(); public: void unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation); ::pg_query::RangeVar* unsafe_arena_release_relation(); // .pg_query.Node where_clause = 3 [json_name = "whereClause"]; bool has_where_clause() const; private: bool _internal_has_where_clause() const; public: void clear_where_clause(); const ::pg_query::Node& where_clause() const; PROTOBUF_NODISCARD ::pg_query::Node* release_where_clause(); ::pg_query::Node* mutable_where_clause(); void set_allocated_where_clause(::pg_query::Node* where_clause); private: const ::pg_query::Node& _internal_where_clause() const; ::pg_query::Node* _internal_mutable_where_clause(); public: void unsafe_arena_set_allocated_where_clause( ::pg_query::Node* where_clause); ::pg_query::Node* unsafe_arena_release_where_clause(); // .pg_query.CmdType event = 4 [json_name = "event"]; void clear_event(); ::pg_query::CmdType event() const; void set_event(::pg_query::CmdType value); private: ::pg_query::CmdType _internal_event() const; void _internal_set_event(::pg_query::CmdType value); public: // bool instead = 5 [json_name = "instead"]; void clear_instead(); bool instead() const; void set_instead(bool value); private: bool _internal_instead() const; void _internal_set_instead(bool value); public: // bool replace = 7 [json_name = "replace"]; void clear_replace(); bool replace() const; void set_replace(bool value); private: bool _internal_replace() const; void _internal_set_replace(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.RuleStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > actions_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rulename_; ::pg_query::RangeVar* relation_; ::pg_query::Node* where_clause_; int event_; bool instead_; bool replace_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class NotifyStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.NotifyStmt) */ { public: inline NotifyStmt() : NotifyStmt(nullptr) {} ~NotifyStmt() override; explicit PROTOBUF_CONSTEXPR NotifyStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); NotifyStmt(const NotifyStmt& from); NotifyStmt(NotifyStmt&& from) noexcept : NotifyStmt() { *this = ::std::move(from); } inline NotifyStmt& operator=(const NotifyStmt& from) { CopyFrom(from); return *this; } inline NotifyStmt& operator=(NotifyStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_NotifyStmt_default_instance_); } static constexpr int kIndexInFileMessages = 94; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(NotifyStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- NotifyStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const NotifyStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const NotifyStmt& from) { NotifyStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(NotifyStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.NotifyStmt"; } protected: explicit NotifyStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_conditionname(ArgT0&& arg0, ArgT... args); std::string* mutable_conditionname(); PROTOBUF_NODISCARD std::string* release_conditionname(); void set_allocated_conditionname(std::string* conditionname); 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 void set_payload(ArgT0&& arg0, ArgT... args); std::string* mutable_payload(); PROTOBUF_NODISCARD std::string* release_payload(); void set_allocated_payload(std::string* payload); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conditionname_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class ListenStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ListenStmt) */ { public: inline ListenStmt() : ListenStmt(nullptr) {} ~ListenStmt() override; explicit PROTOBUF_CONSTEXPR ListenStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ListenStmt(const ListenStmt& from); ListenStmt(ListenStmt&& from) noexcept : ListenStmt() { *this = ::std::move(from); } inline ListenStmt& operator=(const ListenStmt& from) { CopyFrom(from); return *this; } inline ListenStmt& operator=(ListenStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_ListenStmt_default_instance_); } static constexpr int kIndexInFileMessages = 95; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ListenStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ListenStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ListenStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ListenStmt& from) { ListenStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ListenStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.ListenStmt"; } protected: explicit ListenStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_conditionname(ArgT0&& arg0, ArgT... args); std::string* mutable_conditionname(); PROTOBUF_NODISCARD std::string* release_conditionname(); void set_allocated_conditionname(std::string* conditionname); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conditionname_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class UnlistenStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.UnlistenStmt) */ { public: inline UnlistenStmt() : UnlistenStmt(nullptr) {} ~UnlistenStmt() override; explicit PROTOBUF_CONSTEXPR UnlistenStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); UnlistenStmt(const UnlistenStmt& from); UnlistenStmt(UnlistenStmt&& from) noexcept : UnlistenStmt() { *this = ::std::move(from); } inline UnlistenStmt& operator=(const UnlistenStmt& from) { CopyFrom(from); return *this; } inline UnlistenStmt& operator=(UnlistenStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_UnlistenStmt_default_instance_); } static constexpr int kIndexInFileMessages = 96; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(UnlistenStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- UnlistenStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const UnlistenStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const UnlistenStmt& from) { UnlistenStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(UnlistenStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.UnlistenStmt"; } protected: explicit UnlistenStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_conditionname(ArgT0&& arg0, ArgT... args); std::string* mutable_conditionname(); PROTOBUF_NODISCARD std::string* release_conditionname(); void set_allocated_conditionname(std::string* conditionname); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conditionname_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class TransactionStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.TransactionStmt) */ { public: inline TransactionStmt() : TransactionStmt(nullptr) {} ~TransactionStmt() override; explicit PROTOBUF_CONSTEXPR TransactionStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); TransactionStmt(const TransactionStmt& from); TransactionStmt(TransactionStmt&& from) noexcept : TransactionStmt() { *this = ::std::move(from); } inline TransactionStmt& operator=(const TransactionStmt& from) { CopyFrom(from); return *this; } inline TransactionStmt& operator=(TransactionStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_TransactionStmt_default_instance_); } static constexpr int kIndexInFileMessages = 97; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(TransactionStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- TransactionStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const TransactionStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const TransactionStmt& from) { TransactionStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(TransactionStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.TransactionStmt"; } protected: explicit TransactionStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // string savepoint_name = 3 [json_name = "savepoint_name"]; void clear_savepoint_name(); const std::string& savepoint_name() const; template void set_savepoint_name(ArgT0&& arg0, ArgT... args); std::string* mutable_savepoint_name(); PROTOBUF_NODISCARD std::string* release_savepoint_name(); void set_allocated_savepoint_name(std::string* savepoint_name); 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 void set_gid(ArgT0&& arg0, ArgT... args); std::string* mutable_gid(); PROTOBUF_NODISCARD std::string* release_gid(); void set_allocated_gid(std::string* gid); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr savepoint_name_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr gid_; int kind_; bool chain_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class ViewStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ViewStmt) */ { public: inline ViewStmt() : ViewStmt(nullptr) {} ~ViewStmt() override; explicit PROTOBUF_CONSTEXPR ViewStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ViewStmt(const ViewStmt& from); ViewStmt(ViewStmt&& from) noexcept : ViewStmt() { *this = ::std::move(from); } inline ViewStmt& operator=(const ViewStmt& from) { CopyFrom(from); return *this; } inline ViewStmt& operator=(ViewStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_ViewStmt_default_instance_); } static constexpr int kIndexInFileMessages = 98; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ViewStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ViewStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ViewStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ViewStmt& from) { ViewStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ViewStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.ViewStmt"; } protected: explicit ViewStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_aliases(); private: const ::pg_query::Node& _internal_aliases(int index) const; ::pg_query::Node* _internal_add_aliases(); public: const ::pg_query::Node& aliases(int index) const; ::pg_query::Node* add_aliases(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& aliases() const; // repeated .pg_query.Node options = 5 [json_name = "options"]; int options_size() const; private: int _internal_options_size() const; public: void clear_options(); ::pg_query::Node* mutable_options(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // .pg_query.RangeVar view = 1 [json_name = "view"]; bool has_view() const; private: bool _internal_has_view() const; public: void clear_view(); const ::pg_query::RangeVar& view() const; PROTOBUF_NODISCARD ::pg_query::RangeVar* release_view(); ::pg_query::RangeVar* mutable_view(); void set_allocated_view(::pg_query::RangeVar* view); private: const ::pg_query::RangeVar& _internal_view() const; ::pg_query::RangeVar* _internal_mutable_view(); public: void unsafe_arena_set_allocated_view( ::pg_query::RangeVar* view); ::pg_query::RangeVar* unsafe_arena_release_view(); // .pg_query.Node query = 3 [json_name = "query"]; bool has_query() const; private: bool _internal_has_query() const; public: void clear_query(); const ::pg_query::Node& query() const; PROTOBUF_NODISCARD ::pg_query::Node* release_query(); ::pg_query::Node* mutable_query(); void set_allocated_query(::pg_query::Node* query); private: const ::pg_query::Node& _internal_query() const; ::pg_query::Node* _internal_mutable_query(); public: void unsafe_arena_set_allocated_query( ::pg_query::Node* query); ::pg_query::Node* unsafe_arena_release_query(); // bool replace = 4 [json_name = "replace"]; void clear_replace(); bool replace() const; void set_replace(bool value); private: bool _internal_replace() const; void _internal_set_replace(bool value); public: // .pg_query.ViewCheckOption with_check_option = 6 [json_name = "withCheckOption"]; void clear_with_check_option(); ::pg_query::ViewCheckOption with_check_option() const; void set_with_check_option(::pg_query::ViewCheckOption value); private: ::pg_query::ViewCheckOption _internal_with_check_option() const; void _internal_set_with_check_option(::pg_query::ViewCheckOption value); public: // @@protoc_insertion_point(class_scope:pg_query.ViewStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > aliases_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::pg_query::RangeVar* view_; ::pg_query::Node* query_; bool replace_; int with_check_option_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class LoadStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.LoadStmt) */ { public: inline LoadStmt() : LoadStmt(nullptr) {} ~LoadStmt() override; explicit PROTOBUF_CONSTEXPR LoadStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); LoadStmt(const LoadStmt& from); LoadStmt(LoadStmt&& from) noexcept : LoadStmt() { *this = ::std::move(from); } inline LoadStmt& operator=(const LoadStmt& from) { CopyFrom(from); return *this; } inline LoadStmt& operator=(LoadStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_LoadStmt_default_instance_); } static constexpr int kIndexInFileMessages = 99; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(LoadStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- LoadStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const LoadStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const LoadStmt& from) { LoadStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(LoadStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.LoadStmt"; } protected: explicit LoadStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_filename(ArgT0&& arg0, ArgT... args); std::string* mutable_filename(); PROTOBUF_NODISCARD std::string* release_filename(); void set_allocated_filename(std::string* filename); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filename_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreateDomainStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateDomainStmt) */ { public: inline CreateDomainStmt() : CreateDomainStmt(nullptr) {} ~CreateDomainStmt() override; explicit PROTOBUF_CONSTEXPR CreateDomainStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreateDomainStmt(const CreateDomainStmt& from); CreateDomainStmt(CreateDomainStmt&& from) noexcept : CreateDomainStmt() { *this = ::std::move(from); } inline CreateDomainStmt& operator=(const CreateDomainStmt& from) { CopyFrom(from); return *this; } inline CreateDomainStmt& operator=(CreateDomainStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreateDomainStmt_default_instance_); } static constexpr int kIndexInFileMessages = 100; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreateDomainStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreateDomainStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreateDomainStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreateDomainStmt& from) { CreateDomainStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreateDomainStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreateDomainStmt"; } protected: explicit CreateDomainStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_domainname(); private: const ::pg_query::Node& _internal_domainname(int index) const; ::pg_query::Node* _internal_add_domainname(); public: const ::pg_query::Node& domainname(int index) const; ::pg_query::Node* add_domainname(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& domainname() const; // repeated .pg_query.Node constraints = 4 [json_name = "constraints"]; int constraints_size() const; private: int _internal_constraints_size() const; public: void clear_constraints(); ::pg_query::Node* mutable_constraints(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_constraints(); private: const ::pg_query::Node& _internal_constraints(int index) const; ::pg_query::Node* _internal_add_constraints(); public: const ::pg_query::Node& constraints(int index) const; ::pg_query::Node* add_constraints(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& constraints() const; // .pg_query.TypeName type_name = 2 [json_name = "typeName"]; bool has_type_name() const; private: bool _internal_has_type_name() const; public: void clear_type_name(); const ::pg_query::TypeName& type_name() const; PROTOBUF_NODISCARD ::pg_query::TypeName* release_type_name(); ::pg_query::TypeName* mutable_type_name(); void set_allocated_type_name(::pg_query::TypeName* type_name); private: const ::pg_query::TypeName& _internal_type_name() const; ::pg_query::TypeName* _internal_mutable_type_name(); public: void unsafe_arena_set_allocated_type_name( ::pg_query::TypeName* type_name); ::pg_query::TypeName* unsafe_arena_release_type_name(); // .pg_query.CollateClause coll_clause = 3 [json_name = "collClause"]; bool has_coll_clause() const; private: bool _internal_has_coll_clause() const; public: void clear_coll_clause(); const ::pg_query::CollateClause& coll_clause() const; PROTOBUF_NODISCARD ::pg_query::CollateClause* release_coll_clause(); ::pg_query::CollateClause* mutable_coll_clause(); void set_allocated_coll_clause(::pg_query::CollateClause* coll_clause); private: const ::pg_query::CollateClause& _internal_coll_clause() const; ::pg_query::CollateClause* _internal_mutable_coll_clause(); public: void unsafe_arena_set_allocated_coll_clause( ::pg_query::CollateClause* coll_clause); ::pg_query::CollateClause* unsafe_arena_release_coll_clause(); // @@protoc_insertion_point(class_scope:pg_query.CreateDomainStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > domainname_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > constraints_; ::pg_query::TypeName* type_name_; ::pg_query::CollateClause* coll_clause_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreatedbStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreatedbStmt) */ { public: inline CreatedbStmt() : CreatedbStmt(nullptr) {} ~CreatedbStmt() override; explicit PROTOBUF_CONSTEXPR CreatedbStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreatedbStmt(const CreatedbStmt& from); CreatedbStmt(CreatedbStmt&& from) noexcept : CreatedbStmt() { *this = ::std::move(from); } inline CreatedbStmt& operator=(const CreatedbStmt& from) { CopyFrom(from); return *this; } inline CreatedbStmt& operator=(CreatedbStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreatedbStmt_default_instance_); } static constexpr int kIndexInFileMessages = 101; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreatedbStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreatedbStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreatedbStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreatedbStmt& from) { CreatedbStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreatedbStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreatedbStmt"; } protected: explicit CreatedbStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // string dbname = 1 [json_name = "dbname"]; void clear_dbname(); const std::string& dbname() const; template void set_dbname(ArgT0&& arg0, ArgT... args); std::string* mutable_dbname(); PROTOBUF_NODISCARD std::string* release_dbname(); void set_allocated_dbname(std::string* dbname); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dbname_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class DropdbStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DropdbStmt) */ { public: inline DropdbStmt() : DropdbStmt(nullptr) {} ~DropdbStmt() override; explicit PROTOBUF_CONSTEXPR DropdbStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); DropdbStmt(const DropdbStmt& from); DropdbStmt(DropdbStmt&& from) noexcept : DropdbStmt() { *this = ::std::move(from); } inline DropdbStmt& operator=(const DropdbStmt& from) { CopyFrom(from); return *this; } inline DropdbStmt& operator=(DropdbStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_DropdbStmt_default_instance_); } static constexpr int kIndexInFileMessages = 102; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(DropdbStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- DropdbStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DropdbStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const DropdbStmt& from) { DropdbStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DropdbStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.DropdbStmt"; } protected: explicit DropdbStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // string dbname = 1 [json_name = "dbname"]; void clear_dbname(); const std::string& dbname() const; template void set_dbname(ArgT0&& arg0, ArgT... args); std::string* mutable_dbname(); PROTOBUF_NODISCARD std::string* release_dbname(); void set_allocated_dbname(std::string* dbname); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dbname_; bool missing_ok_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class VacuumStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.VacuumStmt) */ { public: inline VacuumStmt() : VacuumStmt(nullptr) {} ~VacuumStmt() override; explicit PROTOBUF_CONSTEXPR VacuumStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); VacuumStmt(const VacuumStmt& from); VacuumStmt(VacuumStmt&& from) noexcept : VacuumStmt() { *this = ::std::move(from); } inline VacuumStmt& operator=(const VacuumStmt& from) { CopyFrom(from); return *this; } inline VacuumStmt& operator=(VacuumStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_VacuumStmt_default_instance_); } static constexpr int kIndexInFileMessages = 103; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(VacuumStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- VacuumStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const VacuumStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const VacuumStmt& from) { VacuumStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(VacuumStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.VacuumStmt"; } protected: explicit VacuumStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // repeated .pg_query.Node rels = 2 [json_name = "rels"]; int rels_size() const; private: int _internal_rels_size() const; public: void clear_rels(); ::pg_query::Node* mutable_rels(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_rels(); private: const ::pg_query::Node& _internal_rels(int index) const; ::pg_query::Node* _internal_add_rels(); public: const ::pg_query::Node& rels(int index) const; ::pg_query::Node* add_rels(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& rels() const; // bool is_vacuumcmd = 3 [json_name = "is_vacuumcmd"]; void clear_is_vacuumcmd(); bool is_vacuumcmd() const; void set_is_vacuumcmd(bool value); private: bool _internal_is_vacuumcmd() const; void _internal_set_is_vacuumcmd(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.VacuumStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > rels_; bool is_vacuumcmd_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class ExplainStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ExplainStmt) */ { public: inline ExplainStmt() : ExplainStmt(nullptr) {} ~ExplainStmt() override; explicit PROTOBUF_CONSTEXPR ExplainStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ExplainStmt(const ExplainStmt& from); ExplainStmt(ExplainStmt&& from) noexcept : ExplainStmt() { *this = ::std::move(from); } inline ExplainStmt& operator=(const ExplainStmt& from) { CopyFrom(from); return *this; } inline ExplainStmt& operator=(ExplainStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_ExplainStmt_default_instance_); } static constexpr int kIndexInFileMessages = 104; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ExplainStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ExplainStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ExplainStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ExplainStmt& from) { ExplainStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ExplainStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.ExplainStmt"; } protected: explicit ExplainStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // .pg_query.Node query = 1 [json_name = "query"]; bool has_query() const; private: bool _internal_has_query() const; public: void clear_query(); const ::pg_query::Node& query() const; PROTOBUF_NODISCARD ::pg_query::Node* release_query(); ::pg_query::Node* mutable_query(); void set_allocated_query(::pg_query::Node* query); private: const ::pg_query::Node& _internal_query() const; ::pg_query::Node* _internal_mutable_query(); public: void unsafe_arena_set_allocated_query( ::pg_query::Node* query); ::pg_query::Node* unsafe_arena_release_query(); // @@protoc_insertion_point(class_scope:pg_query.ExplainStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::pg_query::Node* query_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreateTableAsStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateTableAsStmt) */ { public: inline CreateTableAsStmt() : CreateTableAsStmt(nullptr) {} ~CreateTableAsStmt() override; explicit PROTOBUF_CONSTEXPR CreateTableAsStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreateTableAsStmt(const CreateTableAsStmt& from); CreateTableAsStmt(CreateTableAsStmt&& from) noexcept : CreateTableAsStmt() { *this = ::std::move(from); } inline CreateTableAsStmt& operator=(const CreateTableAsStmt& from) { CopyFrom(from); return *this; } inline CreateTableAsStmt& operator=(CreateTableAsStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreateTableAsStmt_default_instance_); } static constexpr int kIndexInFileMessages = 105; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreateTableAsStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreateTableAsStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreateTableAsStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreateTableAsStmt& from) { CreateTableAsStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreateTableAsStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreateTableAsStmt"; } protected: explicit CreateTableAsStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_query() const; public: 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* query); private: const ::pg_query::Node& _internal_query() const; ::pg_query::Node* _internal_mutable_query(); public: void unsafe_arena_set_allocated_query( ::pg_query::Node* query); ::pg_query::Node* unsafe_arena_release_query(); // .pg_query.IntoClause into = 2 [json_name = "into"]; bool has_into() const; private: bool _internal_has_into() const; public: void clear_into(); const ::pg_query::IntoClause& into() const; PROTOBUF_NODISCARD ::pg_query::IntoClause* release_into(); ::pg_query::IntoClause* mutable_into(); void set_allocated_into(::pg_query::IntoClause* into); private: const ::pg_query::IntoClause& _internal_into() const; ::pg_query::IntoClause* _internal_mutable_into(); public: void unsafe_arena_set_allocated_into( ::pg_query::IntoClause* into); ::pg_query::IntoClause* unsafe_arena_release_into(); // .pg_query.ObjectType 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::Node* query_; ::pg_query::IntoClause* into_; int objtype_; bool is_select_into_; bool if_not_exists_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreateSeqStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateSeqStmt) */ { public: inline CreateSeqStmt() : CreateSeqStmt(nullptr) {} ~CreateSeqStmt() override; explicit PROTOBUF_CONSTEXPR CreateSeqStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreateSeqStmt(const CreateSeqStmt& from); CreateSeqStmt(CreateSeqStmt&& from) noexcept : CreateSeqStmt() { *this = ::std::move(from); } inline CreateSeqStmt& operator=(const CreateSeqStmt& from) { CopyFrom(from); return *this; } inline CreateSeqStmt& operator=(CreateSeqStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreateSeqStmt_default_instance_); } static constexpr int kIndexInFileMessages = 106; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreateSeqStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreateSeqStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreateSeqStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreateSeqStmt& from) { CreateSeqStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreateSeqStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreateSeqStmt"; } protected: explicit CreateSeqStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // .pg_query.RangeVar sequence = 1 [json_name = "sequence"]; bool has_sequence() const; private: bool _internal_has_sequence() const; public: void clear_sequence(); const ::pg_query::RangeVar& sequence() const; PROTOBUF_NODISCARD ::pg_query::RangeVar* release_sequence(); ::pg_query::RangeVar* mutable_sequence(); void set_allocated_sequence(::pg_query::RangeVar* sequence); private: const ::pg_query::RangeVar& _internal_sequence() const; ::pg_query::RangeVar* _internal_mutable_sequence(); public: void unsafe_arena_set_allocated_sequence( ::pg_query::RangeVar* sequence); ::pg_query::RangeVar* unsafe_arena_release_sequence(); // uint32 owner_id = 3 [json_name = "ownerId"]; void clear_owner_id(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::pg_query::RangeVar* sequence_; uint32_t owner_id_; bool for_identity_; bool if_not_exists_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterSeqStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterSeqStmt) */ { public: inline AlterSeqStmt() : AlterSeqStmt(nullptr) {} ~AlterSeqStmt() override; explicit PROTOBUF_CONSTEXPR AlterSeqStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterSeqStmt(const AlterSeqStmt& from); AlterSeqStmt(AlterSeqStmt&& from) noexcept : AlterSeqStmt() { *this = ::std::move(from); } inline AlterSeqStmt& operator=(const AlterSeqStmt& from) { CopyFrom(from); return *this; } inline AlterSeqStmt& operator=(AlterSeqStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterSeqStmt_default_instance_); } static constexpr int kIndexInFileMessages = 107; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterSeqStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterSeqStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterSeqStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterSeqStmt& from) { AlterSeqStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterSeqStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterSeqStmt"; } protected: explicit AlterSeqStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // .pg_query.RangeVar sequence = 1 [json_name = "sequence"]; bool has_sequence() const; private: bool _internal_has_sequence() const; public: void clear_sequence(); const ::pg_query::RangeVar& sequence() const; PROTOBUF_NODISCARD ::pg_query::RangeVar* release_sequence(); ::pg_query::RangeVar* mutable_sequence(); void set_allocated_sequence(::pg_query::RangeVar* sequence); private: const ::pg_query::RangeVar& _internal_sequence() const; ::pg_query::RangeVar* _internal_mutable_sequence(); public: void unsafe_arena_set_allocated_sequence( ::pg_query::RangeVar* sequence); ::pg_query::RangeVar* unsafe_arena_release_sequence(); // bool for_identity = 3 [json_name = "for_identity"]; void clear_for_identity(); bool for_identity() const; void set_for_identity(bool value); private: bool _internal_for_identity() const; void _internal_set_for_identity(bool value); public: // bool missing_ok = 4 [json_name = "missing_ok"]; void clear_missing_ok(); bool missing_ok() const; void set_missing_ok(bool value); private: bool _internal_missing_ok() const; void _internal_set_missing_ok(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.AlterSeqStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::pg_query::RangeVar* sequence_; bool for_identity_; bool missing_ok_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class VariableSetStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.VariableSetStmt) */ { public: inline VariableSetStmt() : VariableSetStmt(nullptr) {} ~VariableSetStmt() override; explicit PROTOBUF_CONSTEXPR VariableSetStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); VariableSetStmt(const VariableSetStmt& from); VariableSetStmt(VariableSetStmt&& from) noexcept : VariableSetStmt() { *this = ::std::move(from); } inline VariableSetStmt& operator=(const VariableSetStmt& from) { CopyFrom(from); return *this; } inline VariableSetStmt& operator=(VariableSetStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_VariableSetStmt_default_instance_); } static constexpr int kIndexInFileMessages = 108; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(VariableSetStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- VariableSetStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const VariableSetStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const VariableSetStmt& from) { VariableSetStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(VariableSetStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.VariableSetStmt"; } protected: explicit VariableSetStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_args(); private: const ::pg_query::Node& _internal_args(int index) const; ::pg_query::Node* _internal_add_args(); public: const ::pg_query::Node& args(int index) const; ::pg_query::Node* add_args(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& args() const; // string name = 2 [json_name = "name"]; void clear_name(); const std::string& name() const; template void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; int kind_; bool is_local_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class VariableShowStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.VariableShowStmt) */ { public: inline VariableShowStmt() : VariableShowStmt(nullptr) {} ~VariableShowStmt() override; explicit PROTOBUF_CONSTEXPR VariableShowStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); VariableShowStmt(const VariableShowStmt& from); VariableShowStmt(VariableShowStmt&& from) noexcept : VariableShowStmt() { *this = ::std::move(from); } inline VariableShowStmt& operator=(const VariableShowStmt& from) { CopyFrom(from); return *this; } inline VariableShowStmt& operator=(VariableShowStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_VariableShowStmt_default_instance_); } static constexpr int kIndexInFileMessages = 109; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(VariableShowStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- VariableShowStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const VariableShowStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const VariableShowStmt& from) { VariableShowStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(VariableShowStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.VariableShowStmt"; } protected: explicit VariableShowStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class DiscardStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DiscardStmt) */ { public: inline DiscardStmt() : DiscardStmt(nullptr) {} ~DiscardStmt() override; explicit PROTOBUF_CONSTEXPR DiscardStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); DiscardStmt(const DiscardStmt& from); DiscardStmt(DiscardStmt&& from) noexcept : DiscardStmt() { *this = ::std::move(from); } inline DiscardStmt& operator=(const DiscardStmt& from) { CopyFrom(from); return *this; } inline DiscardStmt& operator=(DiscardStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_DiscardStmt_default_instance_); } static constexpr int kIndexInFileMessages = 110; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(DiscardStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- DiscardStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DiscardStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const DiscardStmt& from) { DiscardStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DiscardStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.DiscardStmt"; } protected: explicit DiscardStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { int target_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreateTrigStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateTrigStmt) */ { public: inline CreateTrigStmt() : CreateTrigStmt(nullptr) {} ~CreateTrigStmt() override; explicit PROTOBUF_CONSTEXPR CreateTrigStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreateTrigStmt(const CreateTrigStmt& from); CreateTrigStmt(CreateTrigStmt&& from) noexcept : CreateTrigStmt() { *this = ::std::move(from); } inline CreateTrigStmt& operator=(const CreateTrigStmt& from) { CopyFrom(from); return *this; } inline CreateTrigStmt& operator=(CreateTrigStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreateTrigStmt_default_instance_); } static constexpr int kIndexInFileMessages = 111; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreateTrigStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreateTrigStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreateTrigStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreateTrigStmt& from) { CreateTrigStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreateTrigStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreateTrigStmt"; } protected: explicit CreateTrigStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_funcname(); private: const ::pg_query::Node& _internal_funcname(int index) const; ::pg_query::Node* _internal_add_funcname(); public: const ::pg_query::Node& funcname(int index) const; ::pg_query::Node* add_funcname(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& funcname() const; // repeated .pg_query.Node args = 6 [json_name = "args"]; int args_size() const; private: int _internal_args_size() const; public: void clear_args(); ::pg_query::Node* mutable_args(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_args(); private: const ::pg_query::Node& _internal_args(int index) const; ::pg_query::Node* _internal_add_args(); public: const ::pg_query::Node& args(int index) const; ::pg_query::Node* add_args(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& args() const; // 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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_columns(); private: const ::pg_query::Node& _internal_columns(int index) const; ::pg_query::Node* _internal_add_columns(); public: const ::pg_query::Node& columns(int index) const; ::pg_query::Node* add_columns(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& columns() const; // repeated .pg_query.Node transition_rels = 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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_transition_rels(); private: const ::pg_query::Node& _internal_transition_rels(int index) const; ::pg_query::Node* _internal_add_transition_rels(); public: const ::pg_query::Node& transition_rels(int index) const; ::pg_query::Node* add_transition_rels(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& transition_rels() const; // string trigname = 3 [json_name = "trigname"]; void clear_trigname(); const std::string& trigname() const; template void set_trigname(ArgT0&& arg0, ArgT... args); std::string* mutable_trigname(); PROTOBUF_NODISCARD std::string* release_trigname(); void set_allocated_trigname(std::string* trigname); 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; private: bool _internal_has_relation() const; public: 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* relation); private: const ::pg_query::RangeVar& _internal_relation() const; ::pg_query::RangeVar* _internal_mutable_relation(); public: void unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation); ::pg_query::RangeVar* unsafe_arena_release_relation(); // .pg_query.Node when_clause = 11 [json_name = "whenClause"]; bool has_when_clause() const; private: bool _internal_has_when_clause() const; public: void clear_when_clause(); const ::pg_query::Node& when_clause() const; PROTOBUF_NODISCARD ::pg_query::Node* release_when_clause(); ::pg_query::Node* mutable_when_clause(); void set_allocated_when_clause(::pg_query::Node* when_clause); private: const ::pg_query::Node& _internal_when_clause() const; ::pg_query::Node* _internal_mutable_when_clause(); public: void unsafe_arena_set_allocated_when_clause( ::pg_query::Node* when_clause); ::pg_query::Node* unsafe_arena_release_when_clause(); // .pg_query.RangeVar constrrel = 15 [json_name = "constrrel"]; bool has_constrrel() const; private: bool _internal_has_constrrel() const; public: 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* constrrel); private: const ::pg_query::RangeVar& _internal_constrrel() const; ::pg_query::RangeVar* _internal_mutable_constrrel(); public: void unsafe_arena_set_allocated_constrrel( ::pg_query::RangeVar* constrrel); ::pg_query::RangeVar* unsafe_arena_release_constrrel(); // 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > funcname_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > columns_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > transition_rels_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr trigname_; ::pg_query::RangeVar* relation_; ::pg_query::Node* when_clause_; ::pg_query::RangeVar* constrrel_; bool replace_; bool isconstraint_; bool row_; bool deferrable_; int32_t timing_; int32_t events_; bool initdeferred_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreatePLangStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreatePLangStmt) */ { public: inline CreatePLangStmt() : CreatePLangStmt(nullptr) {} ~CreatePLangStmt() override; explicit PROTOBUF_CONSTEXPR CreatePLangStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreatePLangStmt(const CreatePLangStmt& from); CreatePLangStmt(CreatePLangStmt&& from) noexcept : CreatePLangStmt() { *this = ::std::move(from); } inline CreatePLangStmt& operator=(const CreatePLangStmt& from) { CopyFrom(from); return *this; } inline CreatePLangStmt& operator=(CreatePLangStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreatePLangStmt_default_instance_); } static constexpr int kIndexInFileMessages = 112; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreatePLangStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreatePLangStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreatePLangStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreatePLangStmt& from) { CreatePLangStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreatePLangStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreatePLangStmt"; } protected: explicit CreatePLangStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_plhandler(); private: const ::pg_query::Node& _internal_plhandler(int index) const; ::pg_query::Node* _internal_add_plhandler(); public: const ::pg_query::Node& plhandler(int index) const; ::pg_query::Node* add_plhandler(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& plhandler() const; // repeated .pg_query.Node plinline = 4 [json_name = "plinline"]; int plinline_size() const; private: int _internal_plinline_size() const; public: void clear_plinline(); ::pg_query::Node* mutable_plinline(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_plinline(); private: const ::pg_query::Node& _internal_plinline(int index) const; ::pg_query::Node* _internal_add_plinline(); public: const ::pg_query::Node& plinline(int index) const; ::pg_query::Node* add_plinline(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& plinline() const; // repeated .pg_query.Node plvalidator = 5 [json_name = "plvalidator"]; int plvalidator_size() const; private: int _internal_plvalidator_size() const; public: void clear_plvalidator(); ::pg_query::Node* mutable_plvalidator(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_plvalidator(); private: const ::pg_query::Node& _internal_plvalidator(int index) const; ::pg_query::Node* _internal_add_plvalidator(); public: const ::pg_query::Node& plvalidator(int index) const; ::pg_query::Node* add_plvalidator(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& plvalidator() const; // string plname = 2 [json_name = "plname"]; void clear_plname(); const std::string& plname() const; template void set_plname(ArgT0&& arg0, ArgT... args); std::string* mutable_plname(); PROTOBUF_NODISCARD std::string* release_plname(); void set_allocated_plname(std::string* plname); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > plhandler_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > plinline_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > plvalidator_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr plname_; bool replace_; bool pltrusted_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreateRoleStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateRoleStmt) */ { public: inline CreateRoleStmt() : CreateRoleStmt(nullptr) {} ~CreateRoleStmt() override; explicit PROTOBUF_CONSTEXPR CreateRoleStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreateRoleStmt(const CreateRoleStmt& from); CreateRoleStmt(CreateRoleStmt&& from) noexcept : CreateRoleStmt() { *this = ::std::move(from); } inline CreateRoleStmt& operator=(const CreateRoleStmt& from) { CopyFrom(from); return *this; } inline CreateRoleStmt& operator=(CreateRoleStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreateRoleStmt_default_instance_); } static constexpr int kIndexInFileMessages = 113; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreateRoleStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreateRoleStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreateRoleStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreateRoleStmt& from) { CreateRoleStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreateRoleStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreateRoleStmt"; } protected: explicit CreateRoleStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // string role = 2 [json_name = "role"]; void clear_role(); const std::string& role() const; template void set_role(ArgT0&& arg0, ArgT... args); std::string* mutable_role(); PROTOBUF_NODISCARD std::string* release_role(); void set_allocated_role(std::string* role); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr role_; int stmt_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterRoleStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterRoleStmt) */ { public: inline AlterRoleStmt() : AlterRoleStmt(nullptr) {} ~AlterRoleStmt() override; explicit PROTOBUF_CONSTEXPR AlterRoleStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterRoleStmt(const AlterRoleStmt& from); AlterRoleStmt(AlterRoleStmt&& from) noexcept : AlterRoleStmt() { *this = ::std::move(from); } inline AlterRoleStmt& operator=(const AlterRoleStmt& from) { CopyFrom(from); return *this; } inline AlterRoleStmt& operator=(AlterRoleStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterRoleStmt_default_instance_); } static constexpr int kIndexInFileMessages = 114; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterRoleStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterRoleStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterRoleStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterRoleStmt& from) { AlterRoleStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterRoleStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterRoleStmt"; } protected: explicit AlterRoleStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // .pg_query.RoleSpec role = 1 [json_name = "role"]; bool has_role() const; private: bool _internal_has_role() const; public: void clear_role(); const ::pg_query::RoleSpec& role() const; PROTOBUF_NODISCARD ::pg_query::RoleSpec* release_role(); ::pg_query::RoleSpec* mutable_role(); void set_allocated_role(::pg_query::RoleSpec* role); private: const ::pg_query::RoleSpec& _internal_role() const; ::pg_query::RoleSpec* _internal_mutable_role(); public: void unsafe_arena_set_allocated_role( ::pg_query::RoleSpec* role); ::pg_query::RoleSpec* unsafe_arena_release_role(); // int32 action = 3 [json_name = "action"]; void clear_action(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::pg_query::RoleSpec* role_; int32_t action_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class DropRoleStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DropRoleStmt) */ { public: inline DropRoleStmt() : DropRoleStmt(nullptr) {} ~DropRoleStmt() override; explicit PROTOBUF_CONSTEXPR DropRoleStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); DropRoleStmt(const DropRoleStmt& from); DropRoleStmt(DropRoleStmt&& from) noexcept : DropRoleStmt() { *this = ::std::move(from); } inline DropRoleStmt& operator=(const DropRoleStmt& from) { CopyFrom(from); return *this; } inline DropRoleStmt& operator=(DropRoleStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_DropRoleStmt_default_instance_); } static constexpr int kIndexInFileMessages = 115; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(DropRoleStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- DropRoleStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DropRoleStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const DropRoleStmt& from) { DropRoleStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DropRoleStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.DropRoleStmt"; } protected: explicit DropRoleStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_roles(); private: const ::pg_query::Node& _internal_roles(int index) const; ::pg_query::Node* _internal_add_roles(); public: const ::pg_query::Node& roles(int index) const; ::pg_query::Node* add_roles(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& roles() const; // bool missing_ok = 2 [json_name = "missing_ok"]; void clear_missing_ok(); bool missing_ok() const; void set_missing_ok(bool value); private: bool _internal_missing_ok() const; void _internal_set_missing_ok(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.DropRoleStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > roles_; bool missing_ok_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class LockStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.LockStmt) */ { public: inline LockStmt() : LockStmt(nullptr) {} ~LockStmt() override; explicit PROTOBUF_CONSTEXPR LockStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); LockStmt(const LockStmt& from); LockStmt(LockStmt&& from) noexcept : LockStmt() { *this = ::std::move(from); } inline LockStmt& operator=(const LockStmt& from) { CopyFrom(from); return *this; } inline LockStmt& operator=(LockStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_LockStmt_default_instance_); } static constexpr int kIndexInFileMessages = 116; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(LockStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- LockStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const LockStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const LockStmt& from) { LockStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(LockStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.LockStmt"; } protected: explicit LockStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_relations(); private: const ::pg_query::Node& _internal_relations(int index) const; ::pg_query::Node* _internal_add_relations(); public: const ::pg_query::Node& relations(int index) const; ::pg_query::Node* add_relations(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& relations() const; // int32 mode = 2 [json_name = "mode"]; void clear_mode(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > relations_; int32_t mode_; bool nowait_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class ConstraintsSetStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ConstraintsSetStmt) */ { public: inline ConstraintsSetStmt() : ConstraintsSetStmt(nullptr) {} ~ConstraintsSetStmt() override; explicit PROTOBUF_CONSTEXPR ConstraintsSetStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ConstraintsSetStmt(const ConstraintsSetStmt& from); ConstraintsSetStmt(ConstraintsSetStmt&& from) noexcept : ConstraintsSetStmt() { *this = ::std::move(from); } inline ConstraintsSetStmt& operator=(const ConstraintsSetStmt& from) { CopyFrom(from); return *this; } inline ConstraintsSetStmt& operator=(ConstraintsSetStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_ConstraintsSetStmt_default_instance_); } static constexpr int kIndexInFileMessages = 117; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ConstraintsSetStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ConstraintsSetStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ConstraintsSetStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ConstraintsSetStmt& from) { ConstraintsSetStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ConstraintsSetStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.ConstraintsSetStmt"; } protected: explicit ConstraintsSetStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_constraints(); private: const ::pg_query::Node& _internal_constraints(int index) const; ::pg_query::Node* _internal_add_constraints(); public: const ::pg_query::Node& constraints(int index) const; ::pg_query::Node* add_constraints(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& constraints() const; // bool deferred = 2 [json_name = "deferred"]; void clear_deferred(); bool deferred() const; void set_deferred(bool value); private: bool _internal_deferred() const; void _internal_set_deferred(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.ConstraintsSetStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > constraints_; bool deferred_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class ReindexStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ReindexStmt) */ { public: inline ReindexStmt() : ReindexStmt(nullptr) {} ~ReindexStmt() override; explicit PROTOBUF_CONSTEXPR ReindexStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ReindexStmt(const ReindexStmt& from); ReindexStmt(ReindexStmt&& from) noexcept : ReindexStmt() { *this = ::std::move(from); } inline ReindexStmt& operator=(const ReindexStmt& from) { CopyFrom(from); return *this; } inline ReindexStmt& operator=(ReindexStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_ReindexStmt_default_instance_); } static constexpr int kIndexInFileMessages = 118; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ReindexStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ReindexStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ReindexStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ReindexStmt& from) { ReindexStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ReindexStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.ReindexStmt"; } protected: explicit ReindexStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_params(); private: const ::pg_query::Node& _internal_params(int index) const; ::pg_query::Node* _internal_add_params(); public: const ::pg_query::Node& params(int index) const; ::pg_query::Node* add_params(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& params() const; // string name = 3 [json_name = "name"]; void clear_name(); const std::string& name() const; template void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); 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; private: bool _internal_has_relation() const; public: 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* relation); private: const ::pg_query::RangeVar& _internal_relation() const; ::pg_query::RangeVar* _internal_mutable_relation(); public: void unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation); ::pg_query::RangeVar* unsafe_arena_release_relation(); // .pg_query.ReindexObjectType kind = 1 [json_name = "kind"]; void clear_kind(); ::pg_query::ReindexObjectType kind() const; void set_kind(::pg_query::ReindexObjectType value); private: ::pg_query::ReindexObjectType _internal_kind() const; void _internal_set_kind(::pg_query::ReindexObjectType value); public: // @@protoc_insertion_point(class_scope:pg_query.ReindexStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > params_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; ::pg_query::RangeVar* relation_; int kind_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CheckPointStmt final : public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:pg_query.CheckPointStmt) */ { public: inline CheckPointStmt() : CheckPointStmt(nullptr) {} explicit PROTOBUF_CONSTEXPR CheckPointStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CheckPointStmt(const CheckPointStmt& from); CheckPointStmt(CheckPointStmt&& from) noexcept : CheckPointStmt() { *this = ::std::move(from); } inline CheckPointStmt& operator=(const CheckPointStmt& from) { CopyFrom(from); return *this; } inline CheckPointStmt& operator=(CheckPointStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CheckPointStmt_default_instance_); } static constexpr int kIndexInFileMessages = 119; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CheckPointStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CheckPointStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom; inline void CopyFrom(const CheckPointStmt& from) { ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from); } using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom; void MergeFrom(const CheckPointStmt& from) { ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from); } public: private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CheckPointStmt"; } protected: explicit CheckPointStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- // @@protoc_insertion_point(class_scope:pg_query.CheckPointStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreateSchemaStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateSchemaStmt) */ { public: inline CreateSchemaStmt() : CreateSchemaStmt(nullptr) {} ~CreateSchemaStmt() override; explicit PROTOBUF_CONSTEXPR CreateSchemaStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreateSchemaStmt(const CreateSchemaStmt& from); CreateSchemaStmt(CreateSchemaStmt&& from) noexcept : CreateSchemaStmt() { *this = ::std::move(from); } inline CreateSchemaStmt& operator=(const CreateSchemaStmt& from) { CopyFrom(from); return *this; } inline CreateSchemaStmt& operator=(CreateSchemaStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreateSchemaStmt_default_instance_); } static constexpr int kIndexInFileMessages = 120; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreateSchemaStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreateSchemaStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreateSchemaStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreateSchemaStmt& from) { CreateSchemaStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreateSchemaStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreateSchemaStmt"; } protected: explicit CreateSchemaStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_schema_elts(); private: const ::pg_query::Node& _internal_schema_elts(int index) const; ::pg_query::Node* _internal_add_schema_elts(); public: const ::pg_query::Node& schema_elts(int index) const; ::pg_query::Node* add_schema_elts(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& schema_elts() const; // string schemaname = 1 [json_name = "schemaname"]; void clear_schemaname(); const std::string& schemaname() const; template void set_schemaname(ArgT0&& arg0, ArgT... args); std::string* mutable_schemaname(); PROTOBUF_NODISCARD std::string* release_schemaname(); void set_allocated_schemaname(std::string* schemaname); 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; private: bool _internal_has_authrole() const; public: 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* authrole); private: const ::pg_query::RoleSpec& _internal_authrole() const; ::pg_query::RoleSpec* _internal_mutable_authrole(); public: void unsafe_arena_set_allocated_authrole( ::pg_query::RoleSpec* authrole); ::pg_query::RoleSpec* unsafe_arena_release_authrole(); // bool if_not_exists = 4 [json_name = "if_not_exists"]; void clear_if_not_exists(); bool if_not_exists() const; void set_if_not_exists(bool value); private: bool _internal_if_not_exists() const; void _internal_set_if_not_exists(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.CreateSchemaStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > schema_elts_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr schemaname_; ::pg_query::RoleSpec* authrole_; bool if_not_exists_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterDatabaseStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterDatabaseStmt) */ { public: inline AlterDatabaseStmt() : AlterDatabaseStmt(nullptr) {} ~AlterDatabaseStmt() override; explicit PROTOBUF_CONSTEXPR AlterDatabaseStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterDatabaseStmt(const AlterDatabaseStmt& from); AlterDatabaseStmt(AlterDatabaseStmt&& from) noexcept : AlterDatabaseStmt() { *this = ::std::move(from); } inline AlterDatabaseStmt& operator=(const AlterDatabaseStmt& from) { CopyFrom(from); return *this; } inline AlterDatabaseStmt& operator=(AlterDatabaseStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterDatabaseStmt_default_instance_); } static constexpr int kIndexInFileMessages = 121; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterDatabaseStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterDatabaseStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterDatabaseStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterDatabaseStmt& from) { AlterDatabaseStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterDatabaseStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterDatabaseStmt"; } protected: explicit AlterDatabaseStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // string dbname = 1 [json_name = "dbname"]; void clear_dbname(); const std::string& dbname() const; template void set_dbname(ArgT0&& arg0, ArgT... args); std::string* mutable_dbname(); PROTOBUF_NODISCARD std::string* release_dbname(); void set_allocated_dbname(std::string* dbname); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dbname_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterDatabaseRefreshCollStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterDatabaseRefreshCollStmt) */ { public: inline AlterDatabaseRefreshCollStmt() : AlterDatabaseRefreshCollStmt(nullptr) {} ~AlterDatabaseRefreshCollStmt() override; explicit PROTOBUF_CONSTEXPR AlterDatabaseRefreshCollStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterDatabaseRefreshCollStmt(const AlterDatabaseRefreshCollStmt& 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 (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterDatabaseRefreshCollStmt_default_instance_); } static constexpr int kIndexInFileMessages = 122; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterDatabaseRefreshCollStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterDatabaseRefreshCollStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterDatabaseRefreshCollStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterDatabaseRefreshCollStmt& from) { AlterDatabaseRefreshCollStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterDatabaseRefreshCollStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterDatabaseRefreshCollStmt"; } protected: explicit AlterDatabaseRefreshCollStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_dbname(ArgT0&& arg0, ArgT... args); std::string* mutable_dbname(); PROTOBUF_NODISCARD std::string* release_dbname(); void set_allocated_dbname(std::string* dbname); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dbname_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterDatabaseSetStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterDatabaseSetStmt) */ { public: inline AlterDatabaseSetStmt() : AlterDatabaseSetStmt(nullptr) {} ~AlterDatabaseSetStmt() override; explicit PROTOBUF_CONSTEXPR AlterDatabaseSetStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterDatabaseSetStmt(const AlterDatabaseSetStmt& from); AlterDatabaseSetStmt(AlterDatabaseSetStmt&& from) noexcept : AlterDatabaseSetStmt() { *this = ::std::move(from); } inline AlterDatabaseSetStmt& operator=(const AlterDatabaseSetStmt& from) { CopyFrom(from); return *this; } inline AlterDatabaseSetStmt& operator=(AlterDatabaseSetStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterDatabaseSetStmt_default_instance_); } static constexpr int kIndexInFileMessages = 123; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterDatabaseSetStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterDatabaseSetStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterDatabaseSetStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterDatabaseSetStmt& from) { AlterDatabaseSetStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterDatabaseSetStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterDatabaseSetStmt"; } protected: explicit AlterDatabaseSetStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_dbname(ArgT0&& arg0, ArgT... args); std::string* mutable_dbname(); PROTOBUF_NODISCARD std::string* release_dbname(); void set_allocated_dbname(std::string* dbname); 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; private: bool _internal_has_setstmt() const; public: 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* setstmt); private: const ::pg_query::VariableSetStmt& _internal_setstmt() const; ::pg_query::VariableSetStmt* _internal_mutable_setstmt(); public: void unsafe_arena_set_allocated_setstmt( ::pg_query::VariableSetStmt* setstmt); ::pg_query::VariableSetStmt* unsafe_arena_release_setstmt(); // @@protoc_insertion_point(class_scope:pg_query.AlterDatabaseSetStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dbname_; ::pg_query::VariableSetStmt* setstmt_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterRoleSetStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterRoleSetStmt) */ { public: inline AlterRoleSetStmt() : AlterRoleSetStmt(nullptr) {} ~AlterRoleSetStmt() override; explicit PROTOBUF_CONSTEXPR AlterRoleSetStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterRoleSetStmt(const AlterRoleSetStmt& from); AlterRoleSetStmt(AlterRoleSetStmt&& from) noexcept : AlterRoleSetStmt() { *this = ::std::move(from); } inline AlterRoleSetStmt& operator=(const AlterRoleSetStmt& from) { CopyFrom(from); return *this; } inline AlterRoleSetStmt& operator=(AlterRoleSetStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterRoleSetStmt_default_instance_); } static constexpr int kIndexInFileMessages = 124; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterRoleSetStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterRoleSetStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterRoleSetStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterRoleSetStmt& from) { AlterRoleSetStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterRoleSetStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterRoleSetStmt"; } protected: explicit AlterRoleSetStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_database(ArgT0&& arg0, ArgT... args); std::string* mutable_database(); PROTOBUF_NODISCARD std::string* release_database(); void set_allocated_database(std::string* database); 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; private: bool _internal_has_role() const; public: 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* role); private: const ::pg_query::RoleSpec& _internal_role() const; ::pg_query::RoleSpec* _internal_mutable_role(); public: void unsafe_arena_set_allocated_role( ::pg_query::RoleSpec* role); ::pg_query::RoleSpec* unsafe_arena_release_role(); // .pg_query.VariableSetStmt setstmt = 3 [json_name = "setstmt"]; bool has_setstmt() const; private: bool _internal_has_setstmt() const; public: void clear_setstmt(); const ::pg_query::VariableSetStmt& setstmt() const; PROTOBUF_NODISCARD ::pg_query::VariableSetStmt* release_setstmt(); ::pg_query::VariableSetStmt* mutable_setstmt(); void set_allocated_setstmt(::pg_query::VariableSetStmt* setstmt); private: const ::pg_query::VariableSetStmt& _internal_setstmt() const; ::pg_query::VariableSetStmt* _internal_mutable_setstmt(); public: void unsafe_arena_set_allocated_setstmt( ::pg_query::VariableSetStmt* setstmt); ::pg_query::VariableSetStmt* unsafe_arena_release_setstmt(); // @@protoc_insertion_point(class_scope:pg_query.AlterRoleSetStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr database_; ::pg_query::RoleSpec* role_; ::pg_query::VariableSetStmt* setstmt_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreateConversionStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateConversionStmt) */ { public: inline CreateConversionStmt() : CreateConversionStmt(nullptr) {} ~CreateConversionStmt() override; explicit PROTOBUF_CONSTEXPR CreateConversionStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreateConversionStmt(const CreateConversionStmt& from); CreateConversionStmt(CreateConversionStmt&& from) noexcept : CreateConversionStmt() { *this = ::std::move(from); } inline CreateConversionStmt& operator=(const CreateConversionStmt& from) { CopyFrom(from); return *this; } inline CreateConversionStmt& operator=(CreateConversionStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreateConversionStmt_default_instance_); } static constexpr int kIndexInFileMessages = 125; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreateConversionStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreateConversionStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreateConversionStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreateConversionStmt& from) { CreateConversionStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreateConversionStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreateConversionStmt"; } protected: explicit CreateConversionStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_conversion_name(); private: const ::pg_query::Node& _internal_conversion_name(int index) const; ::pg_query::Node* _internal_add_conversion_name(); public: const ::pg_query::Node& conversion_name(int index) const; ::pg_query::Node* add_conversion_name(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& conversion_name() const; // repeated .pg_query.Node func_name = 4 [json_name = "func_name"]; int func_name_size() const; private: int _internal_func_name_size() const; public: void clear_func_name(); ::pg_query::Node* mutable_func_name(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_func_name(); private: const ::pg_query::Node& _internal_func_name(int index) const; ::pg_query::Node* _internal_add_func_name(); public: const ::pg_query::Node& func_name(int index) const; ::pg_query::Node* add_func_name(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& func_name() const; // string for_encoding_name = 2 [json_name = "for_encoding_name"]; void clear_for_encoding_name(); const std::string& for_encoding_name() const; template void set_for_encoding_name(ArgT0&& arg0, ArgT... args); std::string* mutable_for_encoding_name(); PROTOBUF_NODISCARD std::string* release_for_encoding_name(); void set_allocated_for_encoding_name(std::string* for_encoding_name); private: const std::string& _internal_for_encoding_name() const; 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 void set_to_encoding_name(ArgT0&& arg0, ArgT... args); std::string* mutable_to_encoding_name(); PROTOBUF_NODISCARD std::string* release_to_encoding_name(); void set_allocated_to_encoding_name(std::string* to_encoding_name); private: const std::string& _internal_to_encoding_name() const; 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > conversion_name_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > func_name_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr for_encoding_name_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr to_encoding_name_; bool def_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreateCastStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateCastStmt) */ { public: inline CreateCastStmt() : CreateCastStmt(nullptr) {} ~CreateCastStmt() override; explicit PROTOBUF_CONSTEXPR CreateCastStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreateCastStmt(const CreateCastStmt& from); CreateCastStmt(CreateCastStmt&& from) noexcept : CreateCastStmt() { *this = ::std::move(from); } inline CreateCastStmt& operator=(const CreateCastStmt& from) { CopyFrom(from); return *this; } inline CreateCastStmt& operator=(CreateCastStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreateCastStmt_default_instance_); } static constexpr int kIndexInFileMessages = 126; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreateCastStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreateCastStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreateCastStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreateCastStmt& from) { CreateCastStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreateCastStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreateCastStmt"; } protected: explicit CreateCastStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_sourcetype() const; public: 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* sourcetype); private: const ::pg_query::TypeName& _internal_sourcetype() const; ::pg_query::TypeName* _internal_mutable_sourcetype(); public: void unsafe_arena_set_allocated_sourcetype( ::pg_query::TypeName* sourcetype); ::pg_query::TypeName* unsafe_arena_release_sourcetype(); // .pg_query.TypeName targettype = 2 [json_name = "targettype"]; bool has_targettype() const; private: bool _internal_has_targettype() const; public: void clear_targettype(); const ::pg_query::TypeName& targettype() const; PROTOBUF_NODISCARD ::pg_query::TypeName* release_targettype(); ::pg_query::TypeName* mutable_targettype(); void set_allocated_targettype(::pg_query::TypeName* targettype); private: const ::pg_query::TypeName& _internal_targettype() const; ::pg_query::TypeName* _internal_mutable_targettype(); public: void unsafe_arena_set_allocated_targettype( ::pg_query::TypeName* targettype); ::pg_query::TypeName* unsafe_arena_release_targettype(); // .pg_query.ObjectWithArgs func = 3 [json_name = "func"]; bool has_func() const; private: bool _internal_has_func() const; public: void clear_func(); const ::pg_query::ObjectWithArgs& func() const; PROTOBUF_NODISCARD ::pg_query::ObjectWithArgs* release_func(); ::pg_query::ObjectWithArgs* mutable_func(); void set_allocated_func(::pg_query::ObjectWithArgs* func); private: const ::pg_query::ObjectWithArgs& _internal_func() const; ::pg_query::ObjectWithArgs* _internal_mutable_func(); public: void unsafe_arena_set_allocated_func( ::pg_query::ObjectWithArgs* func); ::pg_query::ObjectWithArgs* unsafe_arena_release_func(); // .pg_query.CoercionContext context = 4 [json_name = "context"]; void clear_context(); ::pg_query::CoercionContext context() const; void set_context(::pg_query::CoercionContext value); private: ::pg_query::CoercionContext _internal_context() const; void _internal_set_context(::pg_query::CoercionContext value); public: // bool inout = 5 [json_name = "inout"]; void clear_inout(); bool inout() const; void set_inout(bool value); private: bool _internal_inout() const; void _internal_set_inout(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.CreateCastStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::TypeName* sourcetype_; ::pg_query::TypeName* targettype_; ::pg_query::ObjectWithArgs* func_; int context_; bool inout_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreateOpClassStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateOpClassStmt) */ { public: inline CreateOpClassStmt() : CreateOpClassStmt(nullptr) {} ~CreateOpClassStmt() override; explicit PROTOBUF_CONSTEXPR CreateOpClassStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreateOpClassStmt(const CreateOpClassStmt& from); CreateOpClassStmt(CreateOpClassStmt&& from) noexcept : CreateOpClassStmt() { *this = ::std::move(from); } inline CreateOpClassStmt& operator=(const CreateOpClassStmt& from) { CopyFrom(from); return *this; } inline CreateOpClassStmt& operator=(CreateOpClassStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreateOpClassStmt_default_instance_); } static constexpr int kIndexInFileMessages = 127; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreateOpClassStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreateOpClassStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreateOpClassStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreateOpClassStmt& from) { CreateOpClassStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreateOpClassStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreateOpClassStmt"; } protected: explicit CreateOpClassStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_opclassname(); private: const ::pg_query::Node& _internal_opclassname(int index) const; ::pg_query::Node* _internal_add_opclassname(); public: const ::pg_query::Node& opclassname(int index) const; ::pg_query::Node* add_opclassname(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& opclassname() const; // repeated .pg_query.Node opfamilyname = 2 [json_name = "opfamilyname"]; int opfamilyname_size() const; private: int _internal_opfamilyname_size() const; public: void clear_opfamilyname(); ::pg_query::Node* mutable_opfamilyname(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_opfamilyname(); private: const ::pg_query::Node& _internal_opfamilyname(int index) const; ::pg_query::Node* _internal_add_opfamilyname(); public: const ::pg_query::Node& opfamilyname(int index) const; ::pg_query::Node* add_opfamilyname(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& opfamilyname() const; // repeated .pg_query.Node items = 5 [json_name = "items"]; int items_size() const; private: int _internal_items_size() const; public: void clear_items(); ::pg_query::Node* mutable_items(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_items(); private: const ::pg_query::Node& _internal_items(int index) const; ::pg_query::Node* _internal_add_items(); public: const ::pg_query::Node& items(int index) const; ::pg_query::Node* add_items(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& items() const; // string amname = 3 [json_name = "amname"]; void clear_amname(); const std::string& amname() const; template void set_amname(ArgT0&& arg0, ArgT... args); std::string* mutable_amname(); PROTOBUF_NODISCARD std::string* release_amname(); void set_allocated_amname(std::string* amname); 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; private: bool _internal_has_datatype() const; public: 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* datatype); private: const ::pg_query::TypeName& _internal_datatype() const; ::pg_query::TypeName* _internal_mutable_datatype(); public: void unsafe_arena_set_allocated_datatype( ::pg_query::TypeName* datatype); ::pg_query::TypeName* unsafe_arena_release_datatype(); // bool is_default = 6 [json_name = "isDefault"]; void clear_is_default(); bool is_default() const; void set_is_default(bool value); private: bool _internal_is_default() const; void _internal_set_is_default(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.CreateOpClassStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > opclassname_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > opfamilyname_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > items_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr amname_; ::pg_query::TypeName* datatype_; bool is_default_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreateOpFamilyStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateOpFamilyStmt) */ { public: inline CreateOpFamilyStmt() : CreateOpFamilyStmt(nullptr) {} ~CreateOpFamilyStmt() override; explicit PROTOBUF_CONSTEXPR CreateOpFamilyStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreateOpFamilyStmt(const CreateOpFamilyStmt& from); CreateOpFamilyStmt(CreateOpFamilyStmt&& from) noexcept : CreateOpFamilyStmt() { *this = ::std::move(from); } inline CreateOpFamilyStmt& operator=(const CreateOpFamilyStmt& from) { CopyFrom(from); return *this; } inline CreateOpFamilyStmt& operator=(CreateOpFamilyStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreateOpFamilyStmt_default_instance_); } static constexpr int kIndexInFileMessages = 128; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreateOpFamilyStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreateOpFamilyStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreateOpFamilyStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreateOpFamilyStmt& from) { CreateOpFamilyStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreateOpFamilyStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreateOpFamilyStmt"; } protected: explicit CreateOpFamilyStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_opfamilyname(); private: const ::pg_query::Node& _internal_opfamilyname(int index) const; ::pg_query::Node* _internal_add_opfamilyname(); public: const ::pg_query::Node& opfamilyname(int index) const; ::pg_query::Node* add_opfamilyname(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& opfamilyname() const; // string amname = 2 [json_name = "amname"]; void clear_amname(); const std::string& amname() const; template void set_amname(ArgT0&& arg0, ArgT... args); std::string* mutable_amname(); PROTOBUF_NODISCARD std::string* release_amname(); void set_allocated_amname(std::string* amname); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > opfamilyname_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr amname_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterOpFamilyStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterOpFamilyStmt) */ { public: inline AlterOpFamilyStmt() : AlterOpFamilyStmt(nullptr) {} ~AlterOpFamilyStmt() override; explicit PROTOBUF_CONSTEXPR AlterOpFamilyStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterOpFamilyStmt(const AlterOpFamilyStmt& from); AlterOpFamilyStmt(AlterOpFamilyStmt&& from) noexcept : AlterOpFamilyStmt() { *this = ::std::move(from); } inline AlterOpFamilyStmt& operator=(const AlterOpFamilyStmt& from) { CopyFrom(from); return *this; } inline AlterOpFamilyStmt& operator=(AlterOpFamilyStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterOpFamilyStmt_default_instance_); } static constexpr int kIndexInFileMessages = 129; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterOpFamilyStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterOpFamilyStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterOpFamilyStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterOpFamilyStmt& from) { AlterOpFamilyStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterOpFamilyStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterOpFamilyStmt"; } protected: explicit AlterOpFamilyStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_opfamilyname(); private: const ::pg_query::Node& _internal_opfamilyname(int index) const; ::pg_query::Node* _internal_add_opfamilyname(); public: const ::pg_query::Node& opfamilyname(int index) const; ::pg_query::Node* add_opfamilyname(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& opfamilyname() const; // repeated .pg_query.Node items = 4 [json_name = "items"]; int items_size() const; private: int _internal_items_size() const; public: void clear_items(); ::pg_query::Node* mutable_items(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_items(); private: const ::pg_query::Node& _internal_items(int index) const; ::pg_query::Node* _internal_add_items(); public: const ::pg_query::Node& items(int index) const; ::pg_query::Node* add_items(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& items() const; // string amname = 2 [json_name = "amname"]; void clear_amname(); const std::string& amname() const; template void set_amname(ArgT0&& arg0, ArgT... args); std::string* mutable_amname(); PROTOBUF_NODISCARD std::string* release_amname(); void set_allocated_amname(std::string* amname); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > opfamilyname_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > items_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr amname_; bool is_drop_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class PrepareStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.PrepareStmt) */ { public: inline PrepareStmt() : PrepareStmt(nullptr) {} ~PrepareStmt() override; explicit PROTOBUF_CONSTEXPR PrepareStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); PrepareStmt(const PrepareStmt& from); PrepareStmt(PrepareStmt&& from) noexcept : PrepareStmt() { *this = ::std::move(from); } inline PrepareStmt& operator=(const PrepareStmt& from) { CopyFrom(from); return *this; } inline PrepareStmt& operator=(PrepareStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_PrepareStmt_default_instance_); } static constexpr int kIndexInFileMessages = 130; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PrepareStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PrepareStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const PrepareStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const PrepareStmt& from) { PrepareStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(PrepareStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.PrepareStmt"; } protected: explicit PrepareStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_argtypes(); private: const ::pg_query::Node& _internal_argtypes(int index) const; ::pg_query::Node* _internal_add_argtypes(); public: const ::pg_query::Node& argtypes(int index) const; ::pg_query::Node* add_argtypes(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& argtypes() const; // string name = 1 [json_name = "name"]; void clear_name(); const std::string& name() const; template void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); 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; private: bool _internal_has_query() const; public: 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* query); private: const ::pg_query::Node& _internal_query() const; ::pg_query::Node* _internal_mutable_query(); public: void unsafe_arena_set_allocated_query( ::pg_query::Node* query); ::pg_query::Node* unsafe_arena_release_query(); // @@protoc_insertion_point(class_scope:pg_query.PrepareStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > argtypes_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; ::pg_query::Node* query_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class ExecuteStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ExecuteStmt) */ { public: inline ExecuteStmt() : ExecuteStmt(nullptr) {} ~ExecuteStmt() override; explicit PROTOBUF_CONSTEXPR ExecuteStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ExecuteStmt(const ExecuteStmt& from); ExecuteStmt(ExecuteStmt&& from) noexcept : ExecuteStmt() { *this = ::std::move(from); } inline ExecuteStmt& operator=(const ExecuteStmt& from) { CopyFrom(from); return *this; } inline ExecuteStmt& operator=(ExecuteStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_ExecuteStmt_default_instance_); } static constexpr int kIndexInFileMessages = 131; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ExecuteStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ExecuteStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ExecuteStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ExecuteStmt& from) { ExecuteStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ExecuteStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.ExecuteStmt"; } protected: explicit ExecuteStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_params(); private: const ::pg_query::Node& _internal_params(int index) const; ::pg_query::Node* _internal_add_params(); public: const ::pg_query::Node& params(int index) const; ::pg_query::Node* add_params(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& params() const; // string name = 1 [json_name = "name"]; void clear_name(); const std::string& name() const; template void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > params_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class DeallocateStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DeallocateStmt) */ { public: inline DeallocateStmt() : DeallocateStmt(nullptr) {} ~DeallocateStmt() override; explicit PROTOBUF_CONSTEXPR DeallocateStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); DeallocateStmt(const DeallocateStmt& from); DeallocateStmt(DeallocateStmt&& from) noexcept : DeallocateStmt() { *this = ::std::move(from); } inline DeallocateStmt& operator=(const DeallocateStmt& from) { CopyFrom(from); return *this; } inline DeallocateStmt& operator=(DeallocateStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_DeallocateStmt_default_instance_); } static constexpr int kIndexInFileMessages = 132; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(DeallocateStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- DeallocateStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DeallocateStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const DeallocateStmt& from) { DeallocateStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DeallocateStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.DeallocateStmt"; } protected: explicit DeallocateStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class DeclareCursorStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DeclareCursorStmt) */ { public: inline DeclareCursorStmt() : DeclareCursorStmt(nullptr) {} ~DeclareCursorStmt() override; explicit PROTOBUF_CONSTEXPR DeclareCursorStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); DeclareCursorStmt(const DeclareCursorStmt& from); DeclareCursorStmt(DeclareCursorStmt&& from) noexcept : DeclareCursorStmt() { *this = ::std::move(from); } inline DeclareCursorStmt& operator=(const DeclareCursorStmt& from) { CopyFrom(from); return *this; } inline DeclareCursorStmt& operator=(DeclareCursorStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_DeclareCursorStmt_default_instance_); } static constexpr int kIndexInFileMessages = 133; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(DeclareCursorStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- DeclareCursorStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DeclareCursorStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const DeclareCursorStmt& from) { DeclareCursorStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DeclareCursorStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.DeclareCursorStmt"; } protected: explicit DeclareCursorStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_portalname(ArgT0&& arg0, ArgT... args); std::string* mutable_portalname(); PROTOBUF_NODISCARD std::string* release_portalname(); void set_allocated_portalname(std::string* portalname); 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; private: bool _internal_has_query() const; public: 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* query); private: const ::pg_query::Node& _internal_query() const; ::pg_query::Node* _internal_mutable_query(); public: void unsafe_arena_set_allocated_query( ::pg_query::Node* query); ::pg_query::Node* unsafe_arena_release_query(); // int32 options = 2 [json_name = "options"]; void clear_options(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr portalname_; ::pg_query::Node* query_; int32_t options_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreateTableSpaceStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateTableSpaceStmt) */ { public: inline CreateTableSpaceStmt() : CreateTableSpaceStmt(nullptr) {} ~CreateTableSpaceStmt() override; explicit PROTOBUF_CONSTEXPR CreateTableSpaceStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreateTableSpaceStmt(const CreateTableSpaceStmt& from); CreateTableSpaceStmt(CreateTableSpaceStmt&& from) noexcept : CreateTableSpaceStmt() { *this = ::std::move(from); } inline CreateTableSpaceStmt& operator=(const CreateTableSpaceStmt& from) { CopyFrom(from); return *this; } inline CreateTableSpaceStmt& operator=(CreateTableSpaceStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreateTableSpaceStmt_default_instance_); } static constexpr int kIndexInFileMessages = 134; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreateTableSpaceStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreateTableSpaceStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreateTableSpaceStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreateTableSpaceStmt& from) { CreateTableSpaceStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreateTableSpaceStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreateTableSpaceStmt"; } protected: explicit CreateTableSpaceStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // string tablespacename = 1 [json_name = "tablespacename"]; void clear_tablespacename(); const std::string& tablespacename() const; template void set_tablespacename(ArgT0&& arg0, ArgT... args); std::string* mutable_tablespacename(); PROTOBUF_NODISCARD std::string* release_tablespacename(); void set_allocated_tablespacename(std::string* tablespacename); 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 void set_location(ArgT0&& arg0, ArgT... args); std::string* mutable_location(); PROTOBUF_NODISCARD std::string* release_location(); void set_allocated_location(std::string* location); 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; private: bool _internal_has_owner() const; public: 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* owner); private: const ::pg_query::RoleSpec& _internal_owner() const; ::pg_query::RoleSpec* _internal_mutable_owner(); public: void unsafe_arena_set_allocated_owner( ::pg_query::RoleSpec* owner); ::pg_query::RoleSpec* unsafe_arena_release_owner(); // @@protoc_insertion_point(class_scope:pg_query.CreateTableSpaceStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tablespacename_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr location_; ::pg_query::RoleSpec* owner_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class DropTableSpaceStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DropTableSpaceStmt) */ { public: inline DropTableSpaceStmt() : DropTableSpaceStmt(nullptr) {} ~DropTableSpaceStmt() override; explicit PROTOBUF_CONSTEXPR DropTableSpaceStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); DropTableSpaceStmt(const DropTableSpaceStmt& from); DropTableSpaceStmt(DropTableSpaceStmt&& from) noexcept : DropTableSpaceStmt() { *this = ::std::move(from); } inline DropTableSpaceStmt& operator=(const DropTableSpaceStmt& from) { CopyFrom(from); return *this; } inline DropTableSpaceStmt& operator=(DropTableSpaceStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_DropTableSpaceStmt_default_instance_); } static constexpr int kIndexInFileMessages = 135; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(DropTableSpaceStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- DropTableSpaceStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DropTableSpaceStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const DropTableSpaceStmt& from) { DropTableSpaceStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DropTableSpaceStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.DropTableSpaceStmt"; } protected: explicit DropTableSpaceStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_tablespacename(ArgT0&& arg0, ArgT... args); std::string* mutable_tablespacename(); PROTOBUF_NODISCARD std::string* release_tablespacename(); void set_allocated_tablespacename(std::string* tablespacename); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tablespacename_; bool missing_ok_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterObjectDependsStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterObjectDependsStmt) */ { public: inline AlterObjectDependsStmt() : AlterObjectDependsStmt(nullptr) {} ~AlterObjectDependsStmt() override; explicit PROTOBUF_CONSTEXPR AlterObjectDependsStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterObjectDependsStmt(const AlterObjectDependsStmt& from); AlterObjectDependsStmt(AlterObjectDependsStmt&& from) noexcept : AlterObjectDependsStmt() { *this = ::std::move(from); } inline AlterObjectDependsStmt& operator=(const AlterObjectDependsStmt& from) { CopyFrom(from); return *this; } inline AlterObjectDependsStmt& operator=(AlterObjectDependsStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterObjectDependsStmt_default_instance_); } static constexpr int kIndexInFileMessages = 136; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterObjectDependsStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterObjectDependsStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterObjectDependsStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterObjectDependsStmt& from) { AlterObjectDependsStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterObjectDependsStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterObjectDependsStmt"; } protected: explicit AlterObjectDependsStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_relation() const; public: 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* relation); private: const ::pg_query::RangeVar& _internal_relation() const; ::pg_query::RangeVar* _internal_mutable_relation(); public: void unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation); ::pg_query::RangeVar* unsafe_arena_release_relation(); // .pg_query.Node object = 3 [json_name = "object"]; bool has_object() const; private: bool _internal_has_object() const; public: void clear_object(); const ::pg_query::Node& object() const; PROTOBUF_NODISCARD ::pg_query::Node* release_object(); ::pg_query::Node* mutable_object(); void set_allocated_object(::pg_query::Node* object); private: const ::pg_query::Node& _internal_object() const; ::pg_query::Node* _internal_mutable_object(); public: void unsafe_arena_set_allocated_object( ::pg_query::Node* object); ::pg_query::Node* unsafe_arena_release_object(); // .pg_query.String extname = 4 [json_name = "extname"]; bool has_extname() const; private: bool _internal_has_extname() const; public: 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* extname); private: const ::pg_query::String& _internal_extname() const; ::pg_query::String* _internal_mutable_extname(); public: void unsafe_arena_set_allocated_extname( ::pg_query::String* extname); ::pg_query::String* unsafe_arena_release_extname(); // .pg_query.ObjectType object_type = 1 [json_name = "objectType"]; void clear_object_type(); ::pg_query::ObjectType object_type() const; void set_object_type(::pg_query::ObjectType value); private: ::pg_query::ObjectType _internal_object_type() const; void _internal_set_object_type(::pg_query::ObjectType value); public: // bool remove = 5 [json_name = "remove"]; void clear_remove(); bool remove() const; void set_remove(bool value); private: bool _internal_remove() const; void _internal_set_remove(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.AlterObjectDependsStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::RangeVar* relation_; ::pg_query::Node* object_; ::pg_query::String* extname_; int object_type_; bool remove_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterObjectSchemaStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterObjectSchemaStmt) */ { public: inline AlterObjectSchemaStmt() : AlterObjectSchemaStmt(nullptr) {} ~AlterObjectSchemaStmt() override; explicit PROTOBUF_CONSTEXPR AlterObjectSchemaStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterObjectSchemaStmt(const AlterObjectSchemaStmt& from); AlterObjectSchemaStmt(AlterObjectSchemaStmt&& from) noexcept : AlterObjectSchemaStmt() { *this = ::std::move(from); } inline AlterObjectSchemaStmt& operator=(const AlterObjectSchemaStmt& from) { CopyFrom(from); return *this; } inline AlterObjectSchemaStmt& operator=(AlterObjectSchemaStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterObjectSchemaStmt_default_instance_); } static constexpr int kIndexInFileMessages = 137; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterObjectSchemaStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterObjectSchemaStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterObjectSchemaStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterObjectSchemaStmt& from) { AlterObjectSchemaStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterObjectSchemaStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterObjectSchemaStmt"; } protected: explicit AlterObjectSchemaStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_newschema(ArgT0&& arg0, ArgT... args); std::string* mutable_newschema(); PROTOBUF_NODISCARD std::string* release_newschema(); void set_allocated_newschema(std::string* newschema); 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; private: bool _internal_has_relation() const; public: 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* relation); private: const ::pg_query::RangeVar& _internal_relation() const; ::pg_query::RangeVar* _internal_mutable_relation(); public: void unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation); ::pg_query::RangeVar* unsafe_arena_release_relation(); // .pg_query.Node object = 3 [json_name = "object"]; bool has_object() const; private: bool _internal_has_object() const; public: void clear_object(); const ::pg_query::Node& object() const; PROTOBUF_NODISCARD ::pg_query::Node* release_object(); ::pg_query::Node* mutable_object(); void set_allocated_object(::pg_query::Node* object); private: const ::pg_query::Node& _internal_object() const; ::pg_query::Node* _internal_mutable_object(); public: void unsafe_arena_set_allocated_object( ::pg_query::Node* object); ::pg_query::Node* unsafe_arena_release_object(); // .pg_query.ObjectType object_type = 1 [json_name = "objectType"]; void clear_object_type(); ::pg_query::ObjectType object_type() const; void set_object_type(::pg_query::ObjectType value); private: ::pg_query::ObjectType _internal_object_type() const; void _internal_set_object_type(::pg_query::ObjectType value); public: // bool missing_ok = 5 [json_name = "missing_ok"]; void clear_missing_ok(); bool missing_ok() const; void set_missing_ok(bool value); private: bool _internal_missing_ok() const; void _internal_set_missing_ok(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.AlterObjectSchemaStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr newschema_; ::pg_query::RangeVar* relation_; ::pg_query::Node* object_; int object_type_; bool missing_ok_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterOwnerStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterOwnerStmt) */ { public: inline AlterOwnerStmt() : AlterOwnerStmt(nullptr) {} ~AlterOwnerStmt() override; explicit PROTOBUF_CONSTEXPR AlterOwnerStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterOwnerStmt(const AlterOwnerStmt& from); AlterOwnerStmt(AlterOwnerStmt&& from) noexcept : AlterOwnerStmt() { *this = ::std::move(from); } inline AlterOwnerStmt& operator=(const AlterOwnerStmt& from) { CopyFrom(from); return *this; } inline AlterOwnerStmt& operator=(AlterOwnerStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterOwnerStmt_default_instance_); } static constexpr int kIndexInFileMessages = 138; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterOwnerStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterOwnerStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterOwnerStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterOwnerStmt& from) { AlterOwnerStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterOwnerStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterOwnerStmt"; } protected: explicit AlterOwnerStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_relation() const; public: 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* relation); private: const ::pg_query::RangeVar& _internal_relation() const; ::pg_query::RangeVar* _internal_mutable_relation(); public: void unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation); ::pg_query::RangeVar* unsafe_arena_release_relation(); // .pg_query.Node object = 3 [json_name = "object"]; bool has_object() const; private: bool _internal_has_object() const; public: void clear_object(); const ::pg_query::Node& object() const; PROTOBUF_NODISCARD ::pg_query::Node* release_object(); ::pg_query::Node* mutable_object(); void set_allocated_object(::pg_query::Node* object); private: const ::pg_query::Node& _internal_object() const; ::pg_query::Node* _internal_mutable_object(); public: void unsafe_arena_set_allocated_object( ::pg_query::Node* object); ::pg_query::Node* unsafe_arena_release_object(); // .pg_query.RoleSpec newowner = 4 [json_name = "newowner"]; bool has_newowner() const; private: bool _internal_has_newowner() const; public: void clear_newowner(); const ::pg_query::RoleSpec& newowner() const; PROTOBUF_NODISCARD ::pg_query::RoleSpec* release_newowner(); ::pg_query::RoleSpec* mutable_newowner(); void set_allocated_newowner(::pg_query::RoleSpec* newowner); private: const ::pg_query::RoleSpec& _internal_newowner() const; ::pg_query::RoleSpec* _internal_mutable_newowner(); public: void unsafe_arena_set_allocated_newowner( ::pg_query::RoleSpec* newowner); ::pg_query::RoleSpec* unsafe_arena_release_newowner(); // .pg_query.ObjectType object_type = 1 [json_name = "objectType"]; void clear_object_type(); ::pg_query::ObjectType object_type() const; void set_object_type(::pg_query::ObjectType value); private: ::pg_query::ObjectType _internal_object_type() const; void _internal_set_object_type(::pg_query::ObjectType value); public: // @@protoc_insertion_point(class_scope:pg_query.AlterOwnerStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::RangeVar* relation_; ::pg_query::Node* object_; ::pg_query::RoleSpec* newowner_; int object_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterOperatorStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterOperatorStmt) */ { public: inline AlterOperatorStmt() : AlterOperatorStmt(nullptr) {} ~AlterOperatorStmt() override; explicit PROTOBUF_CONSTEXPR AlterOperatorStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterOperatorStmt(const AlterOperatorStmt& from); AlterOperatorStmt(AlterOperatorStmt&& from) noexcept : AlterOperatorStmt() { *this = ::std::move(from); } inline AlterOperatorStmt& operator=(const AlterOperatorStmt& from) { CopyFrom(from); return *this; } inline AlterOperatorStmt& operator=(AlterOperatorStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterOperatorStmt_default_instance_); } static constexpr int kIndexInFileMessages = 139; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterOperatorStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterOperatorStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterOperatorStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterOperatorStmt& from) { AlterOperatorStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterOperatorStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterOperatorStmt"; } protected: explicit AlterOperatorStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // .pg_query.ObjectWithArgs opername = 1 [json_name = "opername"]; bool has_opername() const; private: bool _internal_has_opername() const; public: void clear_opername(); const ::pg_query::ObjectWithArgs& opername() const; PROTOBUF_NODISCARD ::pg_query::ObjectWithArgs* release_opername(); ::pg_query::ObjectWithArgs* mutable_opername(); void set_allocated_opername(::pg_query::ObjectWithArgs* opername); private: const ::pg_query::ObjectWithArgs& _internal_opername() const; ::pg_query::ObjectWithArgs* _internal_mutable_opername(); public: void unsafe_arena_set_allocated_opername( ::pg_query::ObjectWithArgs* opername); ::pg_query::ObjectWithArgs* unsafe_arena_release_opername(); // @@protoc_insertion_point(class_scope:pg_query.AlterOperatorStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::pg_query::ObjectWithArgs* opername_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterTypeStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterTypeStmt) */ { public: inline AlterTypeStmt() : AlterTypeStmt(nullptr) {} ~AlterTypeStmt() override; explicit PROTOBUF_CONSTEXPR AlterTypeStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterTypeStmt(const AlterTypeStmt& from); AlterTypeStmt(AlterTypeStmt&& from) noexcept : AlterTypeStmt() { *this = ::std::move(from); } inline AlterTypeStmt& operator=(const AlterTypeStmt& from) { CopyFrom(from); return *this; } inline AlterTypeStmt& operator=(AlterTypeStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterTypeStmt_default_instance_); } static constexpr int kIndexInFileMessages = 140; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterTypeStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterTypeStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterTypeStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterTypeStmt& from) { AlterTypeStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterTypeStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterTypeStmt"; } protected: explicit AlterTypeStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_type_name(); private: const ::pg_query::Node& _internal_type_name(int index) const; ::pg_query::Node* _internal_add_type_name(); public: const ::pg_query::Node& type_name(int index) const; ::pg_query::Node* add_type_name(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& type_name() const; // repeated .pg_query.Node options = 2 [json_name = "options"]; int options_size() const; private: int _internal_options_size() const; public: void clear_options(); ::pg_query::Node* mutable_options(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // @@protoc_insertion_point(class_scope:pg_query.AlterTypeStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > type_name_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class DropOwnedStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DropOwnedStmt) */ { public: inline DropOwnedStmt() : DropOwnedStmt(nullptr) {} ~DropOwnedStmt() override; explicit PROTOBUF_CONSTEXPR DropOwnedStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); DropOwnedStmt(const DropOwnedStmt& from); DropOwnedStmt(DropOwnedStmt&& from) noexcept : DropOwnedStmt() { *this = ::std::move(from); } inline DropOwnedStmt& operator=(const DropOwnedStmt& from) { CopyFrom(from); return *this; } inline DropOwnedStmt& operator=(DropOwnedStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_DropOwnedStmt_default_instance_); } static constexpr int kIndexInFileMessages = 141; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(DropOwnedStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- DropOwnedStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DropOwnedStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const DropOwnedStmt& from) { DropOwnedStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DropOwnedStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.DropOwnedStmt"; } protected: explicit DropOwnedStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_roles(); private: const ::pg_query::Node& _internal_roles(int index) const; ::pg_query::Node* _internal_add_roles(); public: const ::pg_query::Node& roles(int index) const; ::pg_query::Node* add_roles(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& roles() const; // .pg_query.DropBehavior behavior = 2 [json_name = "behavior"]; void clear_behavior(); ::pg_query::DropBehavior behavior() const; void set_behavior(::pg_query::DropBehavior value); private: ::pg_query::DropBehavior _internal_behavior() const; void _internal_set_behavior(::pg_query::DropBehavior value); public: // @@protoc_insertion_point(class_scope:pg_query.DropOwnedStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > roles_; int behavior_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class ReassignOwnedStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ReassignOwnedStmt) */ { public: inline ReassignOwnedStmt() : ReassignOwnedStmt(nullptr) {} ~ReassignOwnedStmt() override; explicit PROTOBUF_CONSTEXPR ReassignOwnedStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ReassignOwnedStmt(const ReassignOwnedStmt& from); ReassignOwnedStmt(ReassignOwnedStmt&& from) noexcept : ReassignOwnedStmt() { *this = ::std::move(from); } inline ReassignOwnedStmt& operator=(const ReassignOwnedStmt& from) { CopyFrom(from); return *this; } inline ReassignOwnedStmt& operator=(ReassignOwnedStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_ReassignOwnedStmt_default_instance_); } static constexpr int kIndexInFileMessages = 142; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ReassignOwnedStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ReassignOwnedStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ReassignOwnedStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ReassignOwnedStmt& from) { ReassignOwnedStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ReassignOwnedStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.ReassignOwnedStmt"; } protected: explicit ReassignOwnedStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_roles(); private: const ::pg_query::Node& _internal_roles(int index) const; ::pg_query::Node* _internal_add_roles(); public: const ::pg_query::Node& roles(int index) const; ::pg_query::Node* add_roles(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& roles() const; // .pg_query.RoleSpec newrole = 2 [json_name = "newrole"]; bool has_newrole() const; private: bool _internal_has_newrole() const; public: void clear_newrole(); const ::pg_query::RoleSpec& newrole() const; PROTOBUF_NODISCARD ::pg_query::RoleSpec* release_newrole(); ::pg_query::RoleSpec* mutable_newrole(); void set_allocated_newrole(::pg_query::RoleSpec* newrole); private: const ::pg_query::RoleSpec& _internal_newrole() const; ::pg_query::RoleSpec* _internal_mutable_newrole(); public: void unsafe_arena_set_allocated_newrole( ::pg_query::RoleSpec* newrole); ::pg_query::RoleSpec* unsafe_arena_release_newrole(); // @@protoc_insertion_point(class_scope:pg_query.ReassignOwnedStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > roles_; ::pg_query::RoleSpec* newrole_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CompositeTypeStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CompositeTypeStmt) */ { public: inline CompositeTypeStmt() : CompositeTypeStmt(nullptr) {} ~CompositeTypeStmt() override; explicit PROTOBUF_CONSTEXPR CompositeTypeStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CompositeTypeStmt(const CompositeTypeStmt& from); CompositeTypeStmt(CompositeTypeStmt&& from) noexcept : CompositeTypeStmt() { *this = ::std::move(from); } inline CompositeTypeStmt& operator=(const CompositeTypeStmt& from) { CopyFrom(from); return *this; } inline CompositeTypeStmt& operator=(CompositeTypeStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CompositeTypeStmt_default_instance_); } static constexpr int kIndexInFileMessages = 143; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CompositeTypeStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CompositeTypeStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CompositeTypeStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CompositeTypeStmt& from) { CompositeTypeStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CompositeTypeStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CompositeTypeStmt"; } protected: explicit CompositeTypeStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_coldeflist(); private: const ::pg_query::Node& _internal_coldeflist(int index) const; ::pg_query::Node* _internal_add_coldeflist(); public: const ::pg_query::Node& coldeflist(int index) const; ::pg_query::Node* add_coldeflist(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& coldeflist() const; // .pg_query.RangeVar typevar = 1 [json_name = "typevar"]; bool has_typevar() const; private: bool _internal_has_typevar() const; public: void clear_typevar(); const ::pg_query::RangeVar& typevar() const; PROTOBUF_NODISCARD ::pg_query::RangeVar* release_typevar(); ::pg_query::RangeVar* mutable_typevar(); void set_allocated_typevar(::pg_query::RangeVar* typevar); private: const ::pg_query::RangeVar& _internal_typevar() const; ::pg_query::RangeVar* _internal_mutable_typevar(); public: void unsafe_arena_set_allocated_typevar( ::pg_query::RangeVar* typevar); ::pg_query::RangeVar* unsafe_arena_release_typevar(); // @@protoc_insertion_point(class_scope:pg_query.CompositeTypeStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > coldeflist_; ::pg_query::RangeVar* typevar_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreateEnumStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateEnumStmt) */ { public: inline CreateEnumStmt() : CreateEnumStmt(nullptr) {} ~CreateEnumStmt() override; explicit PROTOBUF_CONSTEXPR CreateEnumStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreateEnumStmt(const CreateEnumStmt& from); CreateEnumStmt(CreateEnumStmt&& from) noexcept : CreateEnumStmt() { *this = ::std::move(from); } inline CreateEnumStmt& operator=(const CreateEnumStmt& from) { CopyFrom(from); return *this; } inline CreateEnumStmt& operator=(CreateEnumStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreateEnumStmt_default_instance_); } static constexpr int kIndexInFileMessages = 144; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreateEnumStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreateEnumStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreateEnumStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreateEnumStmt& from) { CreateEnumStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreateEnumStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreateEnumStmt"; } protected: explicit CreateEnumStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_type_name(); private: const ::pg_query::Node& _internal_type_name(int index) const; ::pg_query::Node* _internal_add_type_name(); public: const ::pg_query::Node& type_name(int index) const; ::pg_query::Node* add_type_name(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& type_name() const; // repeated .pg_query.Node vals = 2 [json_name = "vals"]; int vals_size() const; private: int _internal_vals_size() const; public: void clear_vals(); ::pg_query::Node* mutable_vals(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_vals(); private: const ::pg_query::Node& _internal_vals(int index) const; ::pg_query::Node* _internal_add_vals(); public: const ::pg_query::Node& vals(int index) const; ::pg_query::Node* add_vals(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& vals() const; // @@protoc_insertion_point(class_scope:pg_query.CreateEnumStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > type_name_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > vals_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreateRangeStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateRangeStmt) */ { public: inline CreateRangeStmt() : CreateRangeStmt(nullptr) {} ~CreateRangeStmt() override; explicit PROTOBUF_CONSTEXPR CreateRangeStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreateRangeStmt(const CreateRangeStmt& from); CreateRangeStmt(CreateRangeStmt&& from) noexcept : CreateRangeStmt() { *this = ::std::move(from); } inline CreateRangeStmt& operator=(const CreateRangeStmt& from) { CopyFrom(from); return *this; } inline CreateRangeStmt& operator=(CreateRangeStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreateRangeStmt_default_instance_); } static constexpr int kIndexInFileMessages = 145; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreateRangeStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreateRangeStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreateRangeStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreateRangeStmt& from) { CreateRangeStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreateRangeStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreateRangeStmt"; } protected: explicit CreateRangeStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_type_name(); private: const ::pg_query::Node& _internal_type_name(int index) const; ::pg_query::Node* _internal_add_type_name(); public: const ::pg_query::Node& type_name(int index) const; ::pg_query::Node* add_type_name(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& type_name() const; // repeated .pg_query.Node params = 2 [json_name = "params"]; int params_size() const; private: int _internal_params_size() const; public: void clear_params(); ::pg_query::Node* mutable_params(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_params(); private: const ::pg_query::Node& _internal_params(int index) const; ::pg_query::Node* _internal_add_params(); public: const ::pg_query::Node& params(int index) const; ::pg_query::Node* add_params(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& params() const; // @@protoc_insertion_point(class_scope:pg_query.CreateRangeStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > type_name_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > params_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterEnumStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterEnumStmt) */ { public: inline AlterEnumStmt() : AlterEnumStmt(nullptr) {} ~AlterEnumStmt() override; explicit PROTOBUF_CONSTEXPR AlterEnumStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterEnumStmt(const AlterEnumStmt& from); AlterEnumStmt(AlterEnumStmt&& from) noexcept : AlterEnumStmt() { *this = ::std::move(from); } inline AlterEnumStmt& operator=(const AlterEnumStmt& from) { CopyFrom(from); return *this; } inline AlterEnumStmt& operator=(AlterEnumStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterEnumStmt_default_instance_); } static constexpr int kIndexInFileMessages = 146; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterEnumStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterEnumStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterEnumStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterEnumStmt& from) { AlterEnumStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterEnumStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterEnumStmt"; } protected: explicit AlterEnumStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_type_name(); private: const ::pg_query::Node& _internal_type_name(int index) const; ::pg_query::Node* _internal_add_type_name(); public: const ::pg_query::Node& type_name(int index) const; ::pg_query::Node* add_type_name(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& type_name() const; // string old_val = 2 [json_name = "oldVal"]; void clear_old_val(); const std::string& old_val() const; template void set_old_val(ArgT0&& arg0, ArgT... args); std::string* mutable_old_val(); PROTOBUF_NODISCARD std::string* release_old_val(); void set_allocated_old_val(std::string* old_val); 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 void set_new_val(ArgT0&& arg0, ArgT... args); std::string* mutable_new_val(); PROTOBUF_NODISCARD std::string* release_new_val(); void set_allocated_new_val(std::string* new_val); 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 void set_new_val_neighbor(ArgT0&& arg0, ArgT... args); std::string* mutable_new_val_neighbor(); PROTOBUF_NODISCARD std::string* release_new_val_neighbor(); void set_allocated_new_val_neighbor(std::string* new_val_neighbor); private: const std::string& _internal_new_val_neighbor() const; 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > type_name_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr old_val_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr new_val_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr new_val_neighbor_; bool new_val_is_after_; bool skip_if_new_val_exists_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterTSDictionaryStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterTSDictionaryStmt) */ { public: inline AlterTSDictionaryStmt() : AlterTSDictionaryStmt(nullptr) {} ~AlterTSDictionaryStmt() override; explicit PROTOBUF_CONSTEXPR AlterTSDictionaryStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterTSDictionaryStmt(const AlterTSDictionaryStmt& from); AlterTSDictionaryStmt(AlterTSDictionaryStmt&& from) noexcept : AlterTSDictionaryStmt() { *this = ::std::move(from); } inline AlterTSDictionaryStmt& operator=(const AlterTSDictionaryStmt& from) { CopyFrom(from); return *this; } inline AlterTSDictionaryStmt& operator=(AlterTSDictionaryStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterTSDictionaryStmt_default_instance_); } static constexpr int kIndexInFileMessages = 147; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterTSDictionaryStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterTSDictionaryStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterTSDictionaryStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterTSDictionaryStmt& from) { AlterTSDictionaryStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterTSDictionaryStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterTSDictionaryStmt"; } protected: explicit AlterTSDictionaryStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_dictname(); private: const ::pg_query::Node& _internal_dictname(int index) const; ::pg_query::Node* _internal_add_dictname(); public: const ::pg_query::Node& dictname(int index) const; ::pg_query::Node* add_dictname(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& dictname() const; // repeated .pg_query.Node options = 2 [json_name = "options"]; int options_size() const; private: int _internal_options_size() const; public: void clear_options(); ::pg_query::Node* mutable_options(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // @@protoc_insertion_point(class_scope:pg_query.AlterTSDictionaryStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > dictname_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterTSConfigurationStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterTSConfigurationStmt) */ { public: inline AlterTSConfigurationStmt() : AlterTSConfigurationStmt(nullptr) {} ~AlterTSConfigurationStmt() override; explicit PROTOBUF_CONSTEXPR AlterTSConfigurationStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterTSConfigurationStmt(const AlterTSConfigurationStmt& from); AlterTSConfigurationStmt(AlterTSConfigurationStmt&& from) noexcept : AlterTSConfigurationStmt() { *this = ::std::move(from); } inline AlterTSConfigurationStmt& operator=(const AlterTSConfigurationStmt& from) { CopyFrom(from); return *this; } inline AlterTSConfigurationStmt& operator=(AlterTSConfigurationStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterTSConfigurationStmt_default_instance_); } static constexpr int kIndexInFileMessages = 148; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterTSConfigurationStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterTSConfigurationStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterTSConfigurationStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterTSConfigurationStmt& from) { AlterTSConfigurationStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterTSConfigurationStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterTSConfigurationStmt"; } protected: explicit AlterTSConfigurationStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_cfgname(); private: const ::pg_query::Node& _internal_cfgname(int index) const; ::pg_query::Node* _internal_add_cfgname(); public: const ::pg_query::Node& cfgname(int index) const; ::pg_query::Node* add_cfgname(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& cfgname() const; // repeated .pg_query.Node tokentype = 3 [json_name = "tokentype"]; int tokentype_size() const; private: int _internal_tokentype_size() const; public: void clear_tokentype(); ::pg_query::Node* mutable_tokentype(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_tokentype(); private: const ::pg_query::Node& _internal_tokentype(int index) const; ::pg_query::Node* _internal_add_tokentype(); public: const ::pg_query::Node& tokentype(int index) const; ::pg_query::Node* add_tokentype(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& tokentype() const; // repeated .pg_query.Node dicts = 4 [json_name = "dicts"]; int dicts_size() const; private: int _internal_dicts_size() const; public: void clear_dicts(); ::pg_query::Node* mutable_dicts(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_dicts(); private: const ::pg_query::Node& _internal_dicts(int index) const; ::pg_query::Node* _internal_add_dicts(); public: const ::pg_query::Node& dicts(int index) const; ::pg_query::Node* add_dicts(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& dicts() const; // .pg_query.AlterTSConfigType kind = 1 [json_name = "kind"]; void clear_kind(); ::pg_query::AlterTSConfigType kind() const; void set_kind(::pg_query::AlterTSConfigType value); private: ::pg_query::AlterTSConfigType _internal_kind() const; void _internal_set_kind(::pg_query::AlterTSConfigType value); public: // bool override = 5 [json_name = "override"]; void clear_override(); bool override() const; void set_override(bool value); private: bool _internal_override() const; void _internal_set_override(bool value); public: // bool replace = 6 [json_name = "replace"]; void clear_replace(); bool replace() const; void set_replace(bool value); private: bool _internal_replace() const; void _internal_set_replace(bool value); public: // bool missing_ok = 7 [json_name = "missing_ok"]; void clear_missing_ok(); bool missing_ok() const; void set_missing_ok(bool value); private: bool _internal_missing_ok() const; void _internal_set_missing_ok(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.AlterTSConfigurationStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > cfgname_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > tokentype_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > dicts_; int kind_; bool override_; bool replace_; bool missing_ok_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreateFdwStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateFdwStmt) */ { public: inline CreateFdwStmt() : CreateFdwStmt(nullptr) {} ~CreateFdwStmt() override; explicit PROTOBUF_CONSTEXPR CreateFdwStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreateFdwStmt(const CreateFdwStmt& from); CreateFdwStmt(CreateFdwStmt&& from) noexcept : CreateFdwStmt() { *this = ::std::move(from); } inline CreateFdwStmt& operator=(const CreateFdwStmt& from) { CopyFrom(from); return *this; } inline CreateFdwStmt& operator=(CreateFdwStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreateFdwStmt_default_instance_); } static constexpr int kIndexInFileMessages = 149; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreateFdwStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreateFdwStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreateFdwStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreateFdwStmt& from) { CreateFdwStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreateFdwStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreateFdwStmt"; } protected: explicit CreateFdwStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_func_options(); private: const ::pg_query::Node& _internal_func_options(int index) const; ::pg_query::Node* _internal_add_func_options(); public: const ::pg_query::Node& func_options(int index) const; ::pg_query::Node* add_func_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& func_options() const; // repeated .pg_query.Node options = 3 [json_name = "options"]; int options_size() const; private: int _internal_options_size() const; public: void clear_options(); ::pg_query::Node* mutable_options(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // string fdwname = 1 [json_name = "fdwname"]; void clear_fdwname(); const std::string& fdwname() const; template void set_fdwname(ArgT0&& arg0, ArgT... args); std::string* mutable_fdwname(); PROTOBUF_NODISCARD std::string* release_fdwname(); void set_allocated_fdwname(std::string* fdwname); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > func_options_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fdwname_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterFdwStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterFdwStmt) */ { public: inline AlterFdwStmt() : AlterFdwStmt(nullptr) {} ~AlterFdwStmt() override; explicit PROTOBUF_CONSTEXPR AlterFdwStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterFdwStmt(const AlterFdwStmt& from); AlterFdwStmt(AlterFdwStmt&& from) noexcept : AlterFdwStmt() { *this = ::std::move(from); } inline AlterFdwStmt& operator=(const AlterFdwStmt& from) { CopyFrom(from); return *this; } inline AlterFdwStmt& operator=(AlterFdwStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterFdwStmt_default_instance_); } static constexpr int kIndexInFileMessages = 150; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterFdwStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterFdwStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterFdwStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterFdwStmt& from) { AlterFdwStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterFdwStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterFdwStmt"; } protected: explicit AlterFdwStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_func_options(); private: const ::pg_query::Node& _internal_func_options(int index) const; ::pg_query::Node* _internal_add_func_options(); public: const ::pg_query::Node& func_options(int index) const; ::pg_query::Node* add_func_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& func_options() const; // repeated .pg_query.Node options = 3 [json_name = "options"]; int options_size() const; private: int _internal_options_size() const; public: void clear_options(); ::pg_query::Node* mutable_options(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // string fdwname = 1 [json_name = "fdwname"]; void clear_fdwname(); const std::string& fdwname() const; template void set_fdwname(ArgT0&& arg0, ArgT... args); std::string* mutable_fdwname(); PROTOBUF_NODISCARD std::string* release_fdwname(); void set_allocated_fdwname(std::string* fdwname); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > func_options_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fdwname_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreateForeignServerStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateForeignServerStmt) */ { public: inline CreateForeignServerStmt() : CreateForeignServerStmt(nullptr) {} ~CreateForeignServerStmt() override; explicit PROTOBUF_CONSTEXPR CreateForeignServerStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreateForeignServerStmt(const CreateForeignServerStmt& from); CreateForeignServerStmt(CreateForeignServerStmt&& from) noexcept : CreateForeignServerStmt() { *this = ::std::move(from); } inline CreateForeignServerStmt& operator=(const CreateForeignServerStmt& from) { CopyFrom(from); return *this; } inline CreateForeignServerStmt& operator=(CreateForeignServerStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreateForeignServerStmt_default_instance_); } static constexpr int kIndexInFileMessages = 151; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreateForeignServerStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreateForeignServerStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreateForeignServerStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreateForeignServerStmt& from) { CreateForeignServerStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreateForeignServerStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreateForeignServerStmt"; } protected: explicit CreateForeignServerStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // string servername = 1 [json_name = "servername"]; void clear_servername(); const std::string& servername() const; template void set_servername(ArgT0&& arg0, ArgT... args); std::string* mutable_servername(); PROTOBUF_NODISCARD std::string* release_servername(); void set_allocated_servername(std::string* servername); 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 void set_servertype(ArgT0&& arg0, ArgT... args); std::string* mutable_servertype(); PROTOBUF_NODISCARD std::string* release_servertype(); void set_allocated_servertype(std::string* servertype); 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 void set_version(ArgT0&& arg0, ArgT... args); std::string* mutable_version(); PROTOBUF_NODISCARD std::string* release_version(); void set_allocated_version(std::string* version); 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 void set_fdwname(ArgT0&& arg0, ArgT... args); std::string* mutable_fdwname(); PROTOBUF_NODISCARD std::string* release_fdwname(); void set_allocated_fdwname(std::string* fdwname); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr servername_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr servertype_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fdwname_; bool if_not_exists_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterForeignServerStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterForeignServerStmt) */ { public: inline AlterForeignServerStmt() : AlterForeignServerStmt(nullptr) {} ~AlterForeignServerStmt() override; explicit PROTOBUF_CONSTEXPR AlterForeignServerStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterForeignServerStmt(const AlterForeignServerStmt& from); AlterForeignServerStmt(AlterForeignServerStmt&& from) noexcept : AlterForeignServerStmt() { *this = ::std::move(from); } inline AlterForeignServerStmt& operator=(const AlterForeignServerStmt& from) { CopyFrom(from); return *this; } inline AlterForeignServerStmt& operator=(AlterForeignServerStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterForeignServerStmt_default_instance_); } static constexpr int kIndexInFileMessages = 152; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterForeignServerStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterForeignServerStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterForeignServerStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterForeignServerStmt& from) { AlterForeignServerStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterForeignServerStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterForeignServerStmt"; } protected: explicit AlterForeignServerStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // string servername = 1 [json_name = "servername"]; void clear_servername(); const std::string& servername() const; template void set_servername(ArgT0&& arg0, ArgT... args); std::string* mutable_servername(); PROTOBUF_NODISCARD std::string* release_servername(); void set_allocated_servername(std::string* servername); 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 void set_version(ArgT0&& arg0, ArgT... args); std::string* mutable_version(); PROTOBUF_NODISCARD std::string* release_version(); void set_allocated_version(std::string* version); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr servername_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_; bool has_version_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreateUserMappingStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateUserMappingStmt) */ { public: inline CreateUserMappingStmt() : CreateUserMappingStmt(nullptr) {} ~CreateUserMappingStmt() override; explicit PROTOBUF_CONSTEXPR CreateUserMappingStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreateUserMappingStmt(const CreateUserMappingStmt& from); CreateUserMappingStmt(CreateUserMappingStmt&& from) noexcept : CreateUserMappingStmt() { *this = ::std::move(from); } inline CreateUserMappingStmt& operator=(const CreateUserMappingStmt& from) { CopyFrom(from); return *this; } inline CreateUserMappingStmt& operator=(CreateUserMappingStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreateUserMappingStmt_default_instance_); } static constexpr int kIndexInFileMessages = 153; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreateUserMappingStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreateUserMappingStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreateUserMappingStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreateUserMappingStmt& from) { CreateUserMappingStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreateUserMappingStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreateUserMappingStmt"; } protected: explicit CreateUserMappingStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // string servername = 2 [json_name = "servername"]; void clear_servername(); const std::string& servername() const; template void set_servername(ArgT0&& arg0, ArgT... args); std::string* mutable_servername(); PROTOBUF_NODISCARD std::string* release_servername(); void set_allocated_servername(std::string* servername); 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; private: bool _internal_has_user() const; public: 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* user); private: const ::pg_query::RoleSpec& _internal_user() const; ::pg_query::RoleSpec* _internal_mutable_user(); public: void unsafe_arena_set_allocated_user( ::pg_query::RoleSpec* user); ::pg_query::RoleSpec* unsafe_arena_release_user(); // bool if_not_exists = 3 [json_name = "if_not_exists"]; void clear_if_not_exists(); bool if_not_exists() const; void set_if_not_exists(bool value); private: bool _internal_if_not_exists() const; void _internal_set_if_not_exists(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.CreateUserMappingStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr servername_; ::pg_query::RoleSpec* user_; bool if_not_exists_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterUserMappingStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterUserMappingStmt) */ { public: inline AlterUserMappingStmt() : AlterUserMappingStmt(nullptr) {} ~AlterUserMappingStmt() override; explicit PROTOBUF_CONSTEXPR AlterUserMappingStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterUserMappingStmt(const AlterUserMappingStmt& from); AlterUserMappingStmt(AlterUserMappingStmt&& from) noexcept : AlterUserMappingStmt() { *this = ::std::move(from); } inline AlterUserMappingStmt& operator=(const AlterUserMappingStmt& from) { CopyFrom(from); return *this; } inline AlterUserMappingStmt& operator=(AlterUserMappingStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterUserMappingStmt_default_instance_); } static constexpr int kIndexInFileMessages = 154; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterUserMappingStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterUserMappingStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterUserMappingStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterUserMappingStmt& from) { AlterUserMappingStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterUserMappingStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterUserMappingStmt"; } protected: explicit AlterUserMappingStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // string servername = 2 [json_name = "servername"]; void clear_servername(); const std::string& servername() const; template void set_servername(ArgT0&& arg0, ArgT... args); std::string* mutable_servername(); PROTOBUF_NODISCARD std::string* release_servername(); void set_allocated_servername(std::string* servername); 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; private: bool _internal_has_user() const; public: 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* user); private: const ::pg_query::RoleSpec& _internal_user() const; ::pg_query::RoleSpec* _internal_mutable_user(); public: void unsafe_arena_set_allocated_user( ::pg_query::RoleSpec* user); ::pg_query::RoleSpec* unsafe_arena_release_user(); // @@protoc_insertion_point(class_scope:pg_query.AlterUserMappingStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr servername_; ::pg_query::RoleSpec* user_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class DropUserMappingStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DropUserMappingStmt) */ { public: inline DropUserMappingStmt() : DropUserMappingStmt(nullptr) {} ~DropUserMappingStmt() override; explicit PROTOBUF_CONSTEXPR DropUserMappingStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); DropUserMappingStmt(const DropUserMappingStmt& from); DropUserMappingStmt(DropUserMappingStmt&& from) noexcept : DropUserMappingStmt() { *this = ::std::move(from); } inline DropUserMappingStmt& operator=(const DropUserMappingStmt& from) { CopyFrom(from); return *this; } inline DropUserMappingStmt& operator=(DropUserMappingStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_DropUserMappingStmt_default_instance_); } static constexpr int kIndexInFileMessages = 155; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(DropUserMappingStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- DropUserMappingStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DropUserMappingStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const DropUserMappingStmt& from) { DropUserMappingStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DropUserMappingStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.DropUserMappingStmt"; } protected: explicit DropUserMappingStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_servername(ArgT0&& arg0, ArgT... args); std::string* mutable_servername(); PROTOBUF_NODISCARD std::string* release_servername(); void set_allocated_servername(std::string* servername); 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; private: bool _internal_has_user() const; public: 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* user); private: const ::pg_query::RoleSpec& _internal_user() const; ::pg_query::RoleSpec* _internal_mutable_user(); public: void unsafe_arena_set_allocated_user( ::pg_query::RoleSpec* user); ::pg_query::RoleSpec* unsafe_arena_release_user(); // bool missing_ok = 3 [json_name = "missing_ok"]; void clear_missing_ok(); bool missing_ok() const; void set_missing_ok(bool value); private: bool _internal_missing_ok() const; void _internal_set_missing_ok(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.DropUserMappingStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr servername_; ::pg_query::RoleSpec* user_; bool missing_ok_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterTableSpaceOptionsStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterTableSpaceOptionsStmt) */ { public: inline AlterTableSpaceOptionsStmt() : AlterTableSpaceOptionsStmt(nullptr) {} ~AlterTableSpaceOptionsStmt() override; explicit PROTOBUF_CONSTEXPR AlterTableSpaceOptionsStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterTableSpaceOptionsStmt(const AlterTableSpaceOptionsStmt& from); AlterTableSpaceOptionsStmt(AlterTableSpaceOptionsStmt&& from) noexcept : AlterTableSpaceOptionsStmt() { *this = ::std::move(from); } inline AlterTableSpaceOptionsStmt& operator=(const AlterTableSpaceOptionsStmt& from) { CopyFrom(from); return *this; } inline AlterTableSpaceOptionsStmt& operator=(AlterTableSpaceOptionsStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterTableSpaceOptionsStmt_default_instance_); } static constexpr int kIndexInFileMessages = 156; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterTableSpaceOptionsStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterTableSpaceOptionsStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterTableSpaceOptionsStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterTableSpaceOptionsStmt& from) { AlterTableSpaceOptionsStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterTableSpaceOptionsStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterTableSpaceOptionsStmt"; } protected: explicit AlterTableSpaceOptionsStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // string tablespacename = 1 [json_name = "tablespacename"]; void clear_tablespacename(); const std::string& tablespacename() const; template void set_tablespacename(ArgT0&& arg0, ArgT... args); std::string* mutable_tablespacename(); PROTOBUF_NODISCARD std::string* release_tablespacename(); void set_allocated_tablespacename(std::string* tablespacename); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tablespacename_; bool is_reset_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterTableMoveAllStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterTableMoveAllStmt) */ { public: inline AlterTableMoveAllStmt() : AlterTableMoveAllStmt(nullptr) {} ~AlterTableMoveAllStmt() override; explicit PROTOBUF_CONSTEXPR AlterTableMoveAllStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterTableMoveAllStmt(const AlterTableMoveAllStmt& from); AlterTableMoveAllStmt(AlterTableMoveAllStmt&& from) noexcept : AlterTableMoveAllStmt() { *this = ::std::move(from); } inline AlterTableMoveAllStmt& operator=(const AlterTableMoveAllStmt& from) { CopyFrom(from); return *this; } inline AlterTableMoveAllStmt& operator=(AlterTableMoveAllStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterTableMoveAllStmt_default_instance_); } static constexpr int kIndexInFileMessages = 157; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterTableMoveAllStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterTableMoveAllStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterTableMoveAllStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterTableMoveAllStmt& from) { AlterTableMoveAllStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterTableMoveAllStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterTableMoveAllStmt"; } protected: explicit AlterTableMoveAllStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_roles(); private: const ::pg_query::Node& _internal_roles(int index) const; ::pg_query::Node* _internal_add_roles(); public: const ::pg_query::Node& roles(int index) const; ::pg_query::Node* add_roles(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& roles() const; // string orig_tablespacename = 1 [json_name = "orig_tablespacename"]; void clear_orig_tablespacename(); const std::string& orig_tablespacename() const; template void set_orig_tablespacename(ArgT0&& arg0, ArgT... args); std::string* mutable_orig_tablespacename(); PROTOBUF_NODISCARD std::string* release_orig_tablespacename(); void set_allocated_orig_tablespacename(std::string* orig_tablespacename); 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 void set_new_tablespacename(ArgT0&& arg0, ArgT... args); std::string* mutable_new_tablespacename(); PROTOBUF_NODISCARD std::string* release_new_tablespacename(); void set_allocated_new_tablespacename(std::string* new_tablespacename); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > roles_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr orig_tablespacename_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr new_tablespacename_; int objtype_; bool nowait_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class SecLabelStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.SecLabelStmt) */ { public: inline SecLabelStmt() : SecLabelStmt(nullptr) {} ~SecLabelStmt() override; explicit PROTOBUF_CONSTEXPR SecLabelStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); SecLabelStmt(const SecLabelStmt& from); SecLabelStmt(SecLabelStmt&& from) noexcept : SecLabelStmt() { *this = ::std::move(from); } inline SecLabelStmt& operator=(const SecLabelStmt& from) { CopyFrom(from); return *this; } inline SecLabelStmt& operator=(SecLabelStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_SecLabelStmt_default_instance_); } static constexpr int kIndexInFileMessages = 158; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SecLabelStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- SecLabelStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const SecLabelStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const SecLabelStmt& from) { SecLabelStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(SecLabelStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.SecLabelStmt"; } protected: explicit SecLabelStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_provider(ArgT0&& arg0, ArgT... args); std::string* mutable_provider(); PROTOBUF_NODISCARD std::string* release_provider(); void set_allocated_provider(std::string* provider); 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 void set_label(ArgT0&& arg0, ArgT... args); std::string* mutable_label(); PROTOBUF_NODISCARD std::string* release_label(); void set_allocated_label(std::string* label); 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; private: bool _internal_has_object() const; public: 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* object); private: const ::pg_query::Node& _internal_object() const; ::pg_query::Node* _internal_mutable_object(); public: void unsafe_arena_set_allocated_object( ::pg_query::Node* object); ::pg_query::Node* unsafe_arena_release_object(); // .pg_query.ObjectType objtype = 1 [json_name = "objtype"]; void clear_objtype(); ::pg_query::ObjectType objtype() const; void set_objtype(::pg_query::ObjectType value); private: ::pg_query::ObjectType _internal_objtype() const; void _internal_set_objtype(::pg_query::ObjectType value); public: // @@protoc_insertion_point(class_scope:pg_query.SecLabelStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr label_; ::pg_query::Node* object_; int objtype_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreateForeignTableStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateForeignTableStmt) */ { public: inline CreateForeignTableStmt() : CreateForeignTableStmt(nullptr) {} ~CreateForeignTableStmt() override; explicit PROTOBUF_CONSTEXPR CreateForeignTableStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreateForeignTableStmt(const CreateForeignTableStmt& from); CreateForeignTableStmt(CreateForeignTableStmt&& from) noexcept : CreateForeignTableStmt() { *this = ::std::move(from); } inline CreateForeignTableStmt& operator=(const CreateForeignTableStmt& from) { CopyFrom(from); return *this; } inline CreateForeignTableStmt& operator=(CreateForeignTableStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreateForeignTableStmt_default_instance_); } static constexpr int kIndexInFileMessages = 159; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreateForeignTableStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreateForeignTableStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreateForeignTableStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreateForeignTableStmt& from) { CreateForeignTableStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreateForeignTableStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreateForeignTableStmt"; } protected: explicit CreateForeignTableStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // string servername = 2 [json_name = "servername"]; void clear_servername(); const std::string& servername() const; template void set_servername(ArgT0&& arg0, ArgT... args); std::string* mutable_servername(); PROTOBUF_NODISCARD std::string* release_servername(); void set_allocated_servername(std::string* servername); 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; private: bool _internal_has_base_stmt() const; public: 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* base_stmt); private: const ::pg_query::CreateStmt& _internal_base_stmt() const; ::pg_query::CreateStmt* _internal_mutable_base_stmt(); public: void unsafe_arena_set_allocated_base_stmt( ::pg_query::CreateStmt* base_stmt); ::pg_query::CreateStmt* unsafe_arena_release_base_stmt(); // @@protoc_insertion_point(class_scope:pg_query.CreateForeignTableStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr servername_; ::pg_query::CreateStmt* base_stmt_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class ImportForeignSchemaStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ImportForeignSchemaStmt) */ { public: inline ImportForeignSchemaStmt() : ImportForeignSchemaStmt(nullptr) {} ~ImportForeignSchemaStmt() override; explicit PROTOBUF_CONSTEXPR ImportForeignSchemaStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ImportForeignSchemaStmt(const ImportForeignSchemaStmt& from); ImportForeignSchemaStmt(ImportForeignSchemaStmt&& from) noexcept : ImportForeignSchemaStmt() { *this = ::std::move(from); } inline ImportForeignSchemaStmt& operator=(const ImportForeignSchemaStmt& from) { CopyFrom(from); return *this; } inline ImportForeignSchemaStmt& operator=(ImportForeignSchemaStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_ImportForeignSchemaStmt_default_instance_); } static constexpr int kIndexInFileMessages = 160; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ImportForeignSchemaStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ImportForeignSchemaStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ImportForeignSchemaStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ImportForeignSchemaStmt& from) { ImportForeignSchemaStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ImportForeignSchemaStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.ImportForeignSchemaStmt"; } protected: explicit ImportForeignSchemaStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_table_list(); private: const ::pg_query::Node& _internal_table_list(int index) const; ::pg_query::Node* _internal_add_table_list(); public: const ::pg_query::Node& table_list(int index) const; ::pg_query::Node* add_table_list(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& table_list() const; // repeated .pg_query.Node options = 6 [json_name = "options"]; int options_size() const; private: int _internal_options_size() const; public: void clear_options(); ::pg_query::Node* mutable_options(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // string server_name = 1 [json_name = "server_name"]; void clear_server_name(); const std::string& server_name() const; template void set_server_name(ArgT0&& arg0, ArgT... args); std::string* mutable_server_name(); PROTOBUF_NODISCARD std::string* release_server_name(); void set_allocated_server_name(std::string* server_name); 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 void set_remote_schema(ArgT0&& arg0, ArgT... args); std::string* mutable_remote_schema(); PROTOBUF_NODISCARD std::string* release_remote_schema(); void set_allocated_remote_schema(std::string* remote_schema); 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 void set_local_schema(ArgT0&& arg0, ArgT... args); std::string* mutable_local_schema(); PROTOBUF_NODISCARD std::string* release_local_schema(); void set_allocated_local_schema(std::string* local_schema); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > table_list_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr server_name_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr remote_schema_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr local_schema_; int list_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreateExtensionStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateExtensionStmt) */ { public: inline CreateExtensionStmt() : CreateExtensionStmt(nullptr) {} ~CreateExtensionStmt() override; explicit PROTOBUF_CONSTEXPR CreateExtensionStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreateExtensionStmt(const CreateExtensionStmt& from); CreateExtensionStmt(CreateExtensionStmt&& from) noexcept : CreateExtensionStmt() { *this = ::std::move(from); } inline CreateExtensionStmt& operator=(const CreateExtensionStmt& from) { CopyFrom(from); return *this; } inline CreateExtensionStmt& operator=(CreateExtensionStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreateExtensionStmt_default_instance_); } static constexpr int kIndexInFileMessages = 161; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreateExtensionStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreateExtensionStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreateExtensionStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreateExtensionStmt& from) { CreateExtensionStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreateExtensionStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreateExtensionStmt"; } protected: explicit CreateExtensionStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // string extname = 1 [json_name = "extname"]; void clear_extname(); const std::string& extname() const; template void set_extname(ArgT0&& arg0, ArgT... args); std::string* mutable_extname(); PROTOBUF_NODISCARD std::string* release_extname(); void set_allocated_extname(std::string* extname); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr extname_; bool if_not_exists_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterExtensionStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterExtensionStmt) */ { public: inline AlterExtensionStmt() : AlterExtensionStmt(nullptr) {} ~AlterExtensionStmt() override; explicit PROTOBUF_CONSTEXPR AlterExtensionStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterExtensionStmt(const AlterExtensionStmt& from); AlterExtensionStmt(AlterExtensionStmt&& from) noexcept : AlterExtensionStmt() { *this = ::std::move(from); } inline AlterExtensionStmt& operator=(const AlterExtensionStmt& from) { CopyFrom(from); return *this; } inline AlterExtensionStmt& operator=(AlterExtensionStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterExtensionStmt_default_instance_); } static constexpr int kIndexInFileMessages = 162; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterExtensionStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterExtensionStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterExtensionStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterExtensionStmt& from) { AlterExtensionStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterExtensionStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterExtensionStmt"; } protected: explicit AlterExtensionStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // string extname = 1 [json_name = "extname"]; void clear_extname(); const std::string& extname() const; template void set_extname(ArgT0&& arg0, ArgT... args); std::string* mutable_extname(); PROTOBUF_NODISCARD std::string* release_extname(); void set_allocated_extname(std::string* extname); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr extname_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterExtensionContentsStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterExtensionContentsStmt) */ { public: inline AlterExtensionContentsStmt() : AlterExtensionContentsStmt(nullptr) {} ~AlterExtensionContentsStmt() override; explicit PROTOBUF_CONSTEXPR AlterExtensionContentsStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterExtensionContentsStmt(const AlterExtensionContentsStmt& from); AlterExtensionContentsStmt(AlterExtensionContentsStmt&& from) noexcept : AlterExtensionContentsStmt() { *this = ::std::move(from); } inline AlterExtensionContentsStmt& operator=(const AlterExtensionContentsStmt& from) { CopyFrom(from); return *this; } inline AlterExtensionContentsStmt& operator=(AlterExtensionContentsStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterExtensionContentsStmt_default_instance_); } static constexpr int kIndexInFileMessages = 163; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterExtensionContentsStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterExtensionContentsStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterExtensionContentsStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterExtensionContentsStmt& from) { AlterExtensionContentsStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterExtensionContentsStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterExtensionContentsStmt"; } protected: explicit AlterExtensionContentsStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_extname(ArgT0&& arg0, ArgT... args); std::string* mutable_extname(); PROTOBUF_NODISCARD std::string* release_extname(); void set_allocated_extname(std::string* extname); 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; private: bool _internal_has_object() const; public: 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* object); private: const ::pg_query::Node& _internal_object() const; ::pg_query::Node* _internal_mutable_object(); public: void unsafe_arena_set_allocated_object( ::pg_query::Node* object); ::pg_query::Node* unsafe_arena_release_object(); // int32 action = 2 [json_name = "action"]; void clear_action(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr extname_; ::pg_query::Node* object_; int32_t action_; int objtype_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreateEventTrigStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateEventTrigStmt) */ { public: inline CreateEventTrigStmt() : CreateEventTrigStmt(nullptr) {} ~CreateEventTrigStmt() override; explicit PROTOBUF_CONSTEXPR CreateEventTrigStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreateEventTrigStmt(const CreateEventTrigStmt& from); CreateEventTrigStmt(CreateEventTrigStmt&& from) noexcept : CreateEventTrigStmt() { *this = ::std::move(from); } inline CreateEventTrigStmt& operator=(const CreateEventTrigStmt& from) { CopyFrom(from); return *this; } inline CreateEventTrigStmt& operator=(CreateEventTrigStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreateEventTrigStmt_default_instance_); } static constexpr int kIndexInFileMessages = 164; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreateEventTrigStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreateEventTrigStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreateEventTrigStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreateEventTrigStmt& from) { CreateEventTrigStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreateEventTrigStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreateEventTrigStmt"; } protected: explicit CreateEventTrigStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_whenclause(); private: const ::pg_query::Node& _internal_whenclause(int index) const; ::pg_query::Node* _internal_add_whenclause(); public: const ::pg_query::Node& whenclause(int index) const; ::pg_query::Node* add_whenclause(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& whenclause() const; // repeated .pg_query.Node funcname = 4 [json_name = "funcname"]; int funcname_size() const; private: int _internal_funcname_size() const; public: void clear_funcname(); ::pg_query::Node* mutable_funcname(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_funcname(); private: const ::pg_query::Node& _internal_funcname(int index) const; ::pg_query::Node* _internal_add_funcname(); public: const ::pg_query::Node& funcname(int index) const; ::pg_query::Node* add_funcname(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& funcname() const; // string trigname = 1 [json_name = "trigname"]; void clear_trigname(); const std::string& trigname() const; template void set_trigname(ArgT0&& arg0, ArgT... args); std::string* mutable_trigname(); PROTOBUF_NODISCARD std::string* release_trigname(); void set_allocated_trigname(std::string* trigname); 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 void set_eventname(ArgT0&& arg0, ArgT... args); std::string* mutable_eventname(); PROTOBUF_NODISCARD std::string* release_eventname(); void set_allocated_eventname(std::string* eventname); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > whenclause_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > funcname_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr trigname_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr eventname_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterEventTrigStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterEventTrigStmt) */ { public: inline AlterEventTrigStmt() : AlterEventTrigStmt(nullptr) {} ~AlterEventTrigStmt() override; explicit PROTOBUF_CONSTEXPR AlterEventTrigStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterEventTrigStmt(const AlterEventTrigStmt& from); AlterEventTrigStmt(AlterEventTrigStmt&& from) noexcept : AlterEventTrigStmt() { *this = ::std::move(from); } inline AlterEventTrigStmt& operator=(const AlterEventTrigStmt& from) { CopyFrom(from); return *this; } inline AlterEventTrigStmt& operator=(AlterEventTrigStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterEventTrigStmt_default_instance_); } static constexpr int kIndexInFileMessages = 165; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterEventTrigStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterEventTrigStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterEventTrigStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterEventTrigStmt& from) { AlterEventTrigStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterEventTrigStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterEventTrigStmt"; } protected: explicit AlterEventTrigStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_trigname(ArgT0&& arg0, ArgT... args); std::string* mutable_trigname(); PROTOBUF_NODISCARD std::string* release_trigname(); void set_allocated_trigname(std::string* trigname); 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 void set_tgenabled(ArgT0&& arg0, ArgT... args); std::string* mutable_tgenabled(); PROTOBUF_NODISCARD std::string* release_tgenabled(); void set_allocated_tgenabled(std::string* tgenabled); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr trigname_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tgenabled_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class RefreshMatViewStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RefreshMatViewStmt) */ { public: inline RefreshMatViewStmt() : RefreshMatViewStmt(nullptr) {} ~RefreshMatViewStmt() override; explicit PROTOBUF_CONSTEXPR RefreshMatViewStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); RefreshMatViewStmt(const RefreshMatViewStmt& from); RefreshMatViewStmt(RefreshMatViewStmt&& from) noexcept : RefreshMatViewStmt() { *this = ::std::move(from); } inline RefreshMatViewStmt& operator=(const RefreshMatViewStmt& from) { CopyFrom(from); return *this; } inline RefreshMatViewStmt& operator=(RefreshMatViewStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_RefreshMatViewStmt_default_instance_); } static constexpr int kIndexInFileMessages = 166; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(RefreshMatViewStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- RefreshMatViewStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const RefreshMatViewStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const RefreshMatViewStmt& from) { RefreshMatViewStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(RefreshMatViewStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.RefreshMatViewStmt"; } protected: explicit RefreshMatViewStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_relation() const; public: 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* relation); private: const ::pg_query::RangeVar& _internal_relation() const; ::pg_query::RangeVar* _internal_mutable_relation(); public: void unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation); ::pg_query::RangeVar* unsafe_arena_release_relation(); // bool concurrent = 1 [json_name = "concurrent"]; void clear_concurrent(); bool concurrent() const; void set_concurrent(bool value); private: bool _internal_concurrent() const; void _internal_set_concurrent(bool value); public: // bool skip_data = 2 [json_name = "skipData"]; void clear_skip_data(); bool skip_data() const; void set_skip_data(bool value); private: bool _internal_skip_data() const; void _internal_set_skip_data(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.RefreshMatViewStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::RangeVar* relation_; bool concurrent_; bool skip_data_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class ReplicaIdentityStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ReplicaIdentityStmt) */ { public: inline ReplicaIdentityStmt() : ReplicaIdentityStmt(nullptr) {} ~ReplicaIdentityStmt() override; explicit PROTOBUF_CONSTEXPR ReplicaIdentityStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ReplicaIdentityStmt(const ReplicaIdentityStmt& from); ReplicaIdentityStmt(ReplicaIdentityStmt&& from) noexcept : ReplicaIdentityStmt() { *this = ::std::move(from); } inline ReplicaIdentityStmt& operator=(const ReplicaIdentityStmt& from) { CopyFrom(from); return *this; } inline ReplicaIdentityStmt& operator=(ReplicaIdentityStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_ReplicaIdentityStmt_default_instance_); } static constexpr int kIndexInFileMessages = 167; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ReplicaIdentityStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ReplicaIdentityStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ReplicaIdentityStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ReplicaIdentityStmt& from) { ReplicaIdentityStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ReplicaIdentityStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.ReplicaIdentityStmt"; } protected: explicit ReplicaIdentityStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_identity_type(ArgT0&& arg0, ArgT... args); std::string* mutable_identity_type(); PROTOBUF_NODISCARD std::string* release_identity_type(); void set_allocated_identity_type(std::string* identity_type); 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 void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr identity_type_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterSystemStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterSystemStmt) */ { public: inline AlterSystemStmt() : AlterSystemStmt(nullptr) {} ~AlterSystemStmt() override; explicit PROTOBUF_CONSTEXPR AlterSystemStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterSystemStmt(const AlterSystemStmt& from); AlterSystemStmt(AlterSystemStmt&& from) noexcept : AlterSystemStmt() { *this = ::std::move(from); } inline AlterSystemStmt& operator=(const AlterSystemStmt& from) { CopyFrom(from); return *this; } inline AlterSystemStmt& operator=(AlterSystemStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterSystemStmt_default_instance_); } static constexpr int kIndexInFileMessages = 168; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterSystemStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterSystemStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterSystemStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterSystemStmt& from) { AlterSystemStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterSystemStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterSystemStmt"; } protected: explicit AlterSystemStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kSetstmtFieldNumber = 1, }; // .pg_query.VariableSetStmt setstmt = 1 [json_name = "setstmt"]; bool has_setstmt() const; private: bool _internal_has_setstmt() const; public: void clear_setstmt(); const ::pg_query::VariableSetStmt& setstmt() const; PROTOBUF_NODISCARD ::pg_query::VariableSetStmt* release_setstmt(); ::pg_query::VariableSetStmt* mutable_setstmt(); void set_allocated_setstmt(::pg_query::VariableSetStmt* setstmt); private: const ::pg_query::VariableSetStmt& _internal_setstmt() const; ::pg_query::VariableSetStmt* _internal_mutable_setstmt(); public: void unsafe_arena_set_allocated_setstmt( ::pg_query::VariableSetStmt* setstmt); ::pg_query::VariableSetStmt* unsafe_arena_release_setstmt(); // @@protoc_insertion_point(class_scope:pg_query.AlterSystemStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::VariableSetStmt* setstmt_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreatePolicyStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreatePolicyStmt) */ { public: inline CreatePolicyStmt() : CreatePolicyStmt(nullptr) {} ~CreatePolicyStmt() override; explicit PROTOBUF_CONSTEXPR CreatePolicyStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreatePolicyStmt(const CreatePolicyStmt& from); CreatePolicyStmt(CreatePolicyStmt&& from) noexcept : CreatePolicyStmt() { *this = ::std::move(from); } inline CreatePolicyStmt& operator=(const CreatePolicyStmt& from) { CopyFrom(from); return *this; } inline CreatePolicyStmt& operator=(CreatePolicyStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreatePolicyStmt_default_instance_); } static constexpr int kIndexInFileMessages = 169; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreatePolicyStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreatePolicyStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreatePolicyStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreatePolicyStmt& from) { CreatePolicyStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreatePolicyStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreatePolicyStmt"; } protected: explicit CreatePolicyStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_roles(); private: const ::pg_query::Node& _internal_roles(int index) const; ::pg_query::Node* _internal_add_roles(); public: const ::pg_query::Node& roles(int index) const; ::pg_query::Node* add_roles(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& roles() const; // string policy_name = 1 [json_name = "policy_name"]; void clear_policy_name(); const std::string& policy_name() const; template void set_policy_name(ArgT0&& arg0, ArgT... args); std::string* mutable_policy_name(); PROTOBUF_NODISCARD std::string* release_policy_name(); void set_allocated_policy_name(std::string* policy_name); 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 void set_cmd_name(ArgT0&& arg0, ArgT... args); std::string* mutable_cmd_name(); PROTOBUF_NODISCARD std::string* release_cmd_name(); void set_allocated_cmd_name(std::string* cmd_name); 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; private: bool _internal_has_table() const; public: 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* table); private: const ::pg_query::RangeVar& _internal_table() const; ::pg_query::RangeVar* _internal_mutable_table(); public: void unsafe_arena_set_allocated_table( ::pg_query::RangeVar* table); ::pg_query::RangeVar* unsafe_arena_release_table(); // .pg_query.Node qual = 6 [json_name = "qual"]; bool has_qual() const; private: bool _internal_has_qual() const; public: void clear_qual(); const ::pg_query::Node& qual() const; PROTOBUF_NODISCARD ::pg_query::Node* release_qual(); ::pg_query::Node* mutable_qual(); void set_allocated_qual(::pg_query::Node* qual); private: const ::pg_query::Node& _internal_qual() const; ::pg_query::Node* _internal_mutable_qual(); public: void unsafe_arena_set_allocated_qual( ::pg_query::Node* qual); ::pg_query::Node* unsafe_arena_release_qual(); // .pg_query.Node with_check = 7 [json_name = "with_check"]; bool has_with_check() const; private: bool _internal_has_with_check() const; public: void clear_with_check(); const ::pg_query::Node& with_check() const; PROTOBUF_NODISCARD ::pg_query::Node* release_with_check(); ::pg_query::Node* mutable_with_check(); void set_allocated_with_check(::pg_query::Node* with_check); private: const ::pg_query::Node& _internal_with_check() const; ::pg_query::Node* _internal_mutable_with_check(); public: void unsafe_arena_set_allocated_with_check( ::pg_query::Node* with_check); ::pg_query::Node* unsafe_arena_release_with_check(); // bool permissive = 4 [json_name = "permissive"]; void clear_permissive(); bool permissive() const; void set_permissive(bool value); private: bool _internal_permissive() const; void _internal_set_permissive(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.CreatePolicyStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > roles_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr policy_name_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cmd_name_; ::pg_query::RangeVar* table_; ::pg_query::Node* qual_; ::pg_query::Node* with_check_; bool permissive_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterPolicyStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterPolicyStmt) */ { public: inline AlterPolicyStmt() : AlterPolicyStmt(nullptr) {} ~AlterPolicyStmt() override; explicit PROTOBUF_CONSTEXPR AlterPolicyStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterPolicyStmt(const AlterPolicyStmt& from); AlterPolicyStmt(AlterPolicyStmt&& from) noexcept : AlterPolicyStmt() { *this = ::std::move(from); } inline AlterPolicyStmt& operator=(const AlterPolicyStmt& from) { CopyFrom(from); return *this; } inline AlterPolicyStmt& operator=(AlterPolicyStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterPolicyStmt_default_instance_); } static constexpr int kIndexInFileMessages = 170; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterPolicyStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterPolicyStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterPolicyStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterPolicyStmt& from) { AlterPolicyStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterPolicyStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterPolicyStmt"; } protected: explicit AlterPolicyStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_roles(); private: const ::pg_query::Node& _internal_roles(int index) const; ::pg_query::Node* _internal_add_roles(); public: const ::pg_query::Node& roles(int index) const; ::pg_query::Node* add_roles(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& roles() const; // string policy_name = 1 [json_name = "policy_name"]; void clear_policy_name(); const std::string& policy_name() const; template void set_policy_name(ArgT0&& arg0, ArgT... args); std::string* mutable_policy_name(); PROTOBUF_NODISCARD std::string* release_policy_name(); void set_allocated_policy_name(std::string* policy_name); 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; private: bool _internal_has_table() const; public: 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* table); private: const ::pg_query::RangeVar& _internal_table() const; ::pg_query::RangeVar* _internal_mutable_table(); public: void unsafe_arena_set_allocated_table( ::pg_query::RangeVar* table); ::pg_query::RangeVar* unsafe_arena_release_table(); // .pg_query.Node qual = 4 [json_name = "qual"]; bool has_qual() const; private: bool _internal_has_qual() const; public: void clear_qual(); const ::pg_query::Node& qual() const; PROTOBUF_NODISCARD ::pg_query::Node* release_qual(); ::pg_query::Node* mutable_qual(); void set_allocated_qual(::pg_query::Node* qual); private: const ::pg_query::Node& _internal_qual() const; ::pg_query::Node* _internal_mutable_qual(); public: void unsafe_arena_set_allocated_qual( ::pg_query::Node* qual); ::pg_query::Node* unsafe_arena_release_qual(); // .pg_query.Node with_check = 5 [json_name = "with_check"]; bool has_with_check() const; private: bool _internal_has_with_check() const; public: void clear_with_check(); const ::pg_query::Node& with_check() const; PROTOBUF_NODISCARD ::pg_query::Node* release_with_check(); ::pg_query::Node* mutable_with_check(); void set_allocated_with_check(::pg_query::Node* with_check); private: const ::pg_query::Node& _internal_with_check() const; ::pg_query::Node* _internal_mutable_with_check(); public: void unsafe_arena_set_allocated_with_check( ::pg_query::Node* with_check); ::pg_query::Node* unsafe_arena_release_with_check(); // @@protoc_insertion_point(class_scope:pg_query.AlterPolicyStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > roles_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr policy_name_; ::pg_query::RangeVar* table_; ::pg_query::Node* qual_; ::pg_query::Node* with_check_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreateTransformStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateTransformStmt) */ { public: inline CreateTransformStmt() : CreateTransformStmt(nullptr) {} ~CreateTransformStmt() override; explicit PROTOBUF_CONSTEXPR CreateTransformStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreateTransformStmt(const CreateTransformStmt& from); CreateTransformStmt(CreateTransformStmt&& from) noexcept : CreateTransformStmt() { *this = ::std::move(from); } inline CreateTransformStmt& operator=(const CreateTransformStmt& from) { CopyFrom(from); return *this; } inline CreateTransformStmt& operator=(CreateTransformStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreateTransformStmt_default_instance_); } static constexpr int kIndexInFileMessages = 171; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreateTransformStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreateTransformStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreateTransformStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreateTransformStmt& from) { CreateTransformStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreateTransformStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreateTransformStmt"; } protected: explicit CreateTransformStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_lang(ArgT0&& arg0, ArgT... args); std::string* mutable_lang(); PROTOBUF_NODISCARD std::string* release_lang(); void set_allocated_lang(std::string* lang); 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; 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* type_name); private: const ::pg_query::TypeName& _internal_type_name() const; ::pg_query::TypeName* _internal_mutable_type_name(); public: void unsafe_arena_set_allocated_type_name( ::pg_query::TypeName* type_name); ::pg_query::TypeName* unsafe_arena_release_type_name(); // .pg_query.ObjectWithArgs fromsql = 4 [json_name = "fromsql"]; bool has_fromsql() const; private: bool _internal_has_fromsql() const; public: void clear_fromsql(); const ::pg_query::ObjectWithArgs& fromsql() const; PROTOBUF_NODISCARD ::pg_query::ObjectWithArgs* release_fromsql(); ::pg_query::ObjectWithArgs* mutable_fromsql(); void set_allocated_fromsql(::pg_query::ObjectWithArgs* fromsql); private: const ::pg_query::ObjectWithArgs& _internal_fromsql() const; ::pg_query::ObjectWithArgs* _internal_mutable_fromsql(); public: void unsafe_arena_set_allocated_fromsql( ::pg_query::ObjectWithArgs* fromsql); ::pg_query::ObjectWithArgs* unsafe_arena_release_fromsql(); // .pg_query.ObjectWithArgs tosql = 5 [json_name = "tosql"]; bool has_tosql() const; private: bool _internal_has_tosql() const; public: void clear_tosql(); const ::pg_query::ObjectWithArgs& tosql() const; PROTOBUF_NODISCARD ::pg_query::ObjectWithArgs* release_tosql(); ::pg_query::ObjectWithArgs* mutable_tosql(); void set_allocated_tosql(::pg_query::ObjectWithArgs* tosql); private: const ::pg_query::ObjectWithArgs& _internal_tosql() const; ::pg_query::ObjectWithArgs* _internal_mutable_tosql(); public: void unsafe_arena_set_allocated_tosql( ::pg_query::ObjectWithArgs* tosql); ::pg_query::ObjectWithArgs* unsafe_arena_release_tosql(); // bool replace = 1 [json_name = "replace"]; void clear_replace(); bool replace() const; void set_replace(bool value); private: bool _internal_replace() const; void _internal_set_replace(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.CreateTransformStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr lang_; ::pg_query::TypeName* type_name_; ::pg_query::ObjectWithArgs* fromsql_; ::pg_query::ObjectWithArgs* tosql_; bool replace_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreateAmStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateAmStmt) */ { public: inline CreateAmStmt() : CreateAmStmt(nullptr) {} ~CreateAmStmt() override; explicit PROTOBUF_CONSTEXPR CreateAmStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreateAmStmt(const CreateAmStmt& from); CreateAmStmt(CreateAmStmt&& from) noexcept : CreateAmStmt() { *this = ::std::move(from); } inline CreateAmStmt& operator=(const CreateAmStmt& from) { CopyFrom(from); return *this; } inline CreateAmStmt& operator=(CreateAmStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreateAmStmt_default_instance_); } static constexpr int kIndexInFileMessages = 172; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreateAmStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreateAmStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreateAmStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreateAmStmt& from) { CreateAmStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreateAmStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreateAmStmt"; } protected: explicit CreateAmStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_handler_name(); private: const ::pg_query::Node& _internal_handler_name(int index) const; ::pg_query::Node* _internal_add_handler_name(); public: const ::pg_query::Node& handler_name(int index) const; ::pg_query::Node* add_handler_name(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& handler_name() const; // string amname = 1 [json_name = "amname"]; void clear_amname(); const std::string& amname() const; template void set_amname(ArgT0&& arg0, ArgT... args); std::string* mutable_amname(); PROTOBUF_NODISCARD std::string* release_amname(); void set_allocated_amname(std::string* amname); 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 void set_amtype(ArgT0&& arg0, ArgT... args); std::string* mutable_amtype(); PROTOBUF_NODISCARD std::string* release_amtype(); void set_allocated_amtype(std::string* amtype); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > handler_name_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr amname_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr amtype_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreatePublicationStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreatePublicationStmt) */ { public: inline CreatePublicationStmt() : CreatePublicationStmt(nullptr) {} ~CreatePublicationStmt() override; explicit PROTOBUF_CONSTEXPR CreatePublicationStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreatePublicationStmt(const CreatePublicationStmt& from); CreatePublicationStmt(CreatePublicationStmt&& from) noexcept : CreatePublicationStmt() { *this = ::std::move(from); } inline CreatePublicationStmt& operator=(const CreatePublicationStmt& from) { CopyFrom(from); return *this; } inline CreatePublicationStmt& operator=(CreatePublicationStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreatePublicationStmt_default_instance_); } static constexpr int kIndexInFileMessages = 173; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreatePublicationStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreatePublicationStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreatePublicationStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreatePublicationStmt& from) { CreatePublicationStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreatePublicationStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreatePublicationStmt"; } protected: explicit CreatePublicationStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // repeated .pg_query.Node 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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_pubobjects(); private: const ::pg_query::Node& _internal_pubobjects(int index) const; ::pg_query::Node* _internal_add_pubobjects(); public: const ::pg_query::Node& pubobjects(int index) const; ::pg_query::Node* add_pubobjects(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& pubobjects() const; // string pubname = 1 [json_name = "pubname"]; void clear_pubname(); const std::string& pubname() const; template void set_pubname(ArgT0&& arg0, ArgT... args); std::string* mutable_pubname(); PROTOBUF_NODISCARD std::string* release_pubname(); void set_allocated_pubname(std::string* pubname); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > pubobjects_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pubname_; bool for_all_tables_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterPublicationStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterPublicationStmt) */ { public: inline AlterPublicationStmt() : AlterPublicationStmt(nullptr) {} ~AlterPublicationStmt() override; explicit PROTOBUF_CONSTEXPR AlterPublicationStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterPublicationStmt(const AlterPublicationStmt& from); AlterPublicationStmt(AlterPublicationStmt&& from) noexcept : AlterPublicationStmt() { *this = ::std::move(from); } inline AlterPublicationStmt& operator=(const AlterPublicationStmt& from) { CopyFrom(from); return *this; } inline AlterPublicationStmt& operator=(AlterPublicationStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterPublicationStmt_default_instance_); } static constexpr int kIndexInFileMessages = 174; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterPublicationStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterPublicationStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterPublicationStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterPublicationStmt& from) { AlterPublicationStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterPublicationStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterPublicationStmt"; } protected: explicit AlterPublicationStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // repeated .pg_query.Node 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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_pubobjects(); private: const ::pg_query::Node& _internal_pubobjects(int index) const; ::pg_query::Node* _internal_add_pubobjects(); public: const ::pg_query::Node& pubobjects(int index) const; ::pg_query::Node* add_pubobjects(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& pubobjects() const; // string pubname = 1 [json_name = "pubname"]; void clear_pubname(); const std::string& pubname() const; template void set_pubname(ArgT0&& arg0, ArgT... args); std::string* mutable_pubname(); PROTOBUF_NODISCARD std::string* release_pubname(); void set_allocated_pubname(std::string* pubname); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > pubobjects_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pubname_; bool for_all_tables_; int action_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreateSubscriptionStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateSubscriptionStmt) */ { public: inline CreateSubscriptionStmt() : CreateSubscriptionStmt(nullptr) {} ~CreateSubscriptionStmt() override; explicit PROTOBUF_CONSTEXPR CreateSubscriptionStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreateSubscriptionStmt(const CreateSubscriptionStmt& from); CreateSubscriptionStmt(CreateSubscriptionStmt&& from) noexcept : CreateSubscriptionStmt() { *this = ::std::move(from); } inline CreateSubscriptionStmt& operator=(const CreateSubscriptionStmt& from) { CopyFrom(from); return *this; } inline CreateSubscriptionStmt& operator=(CreateSubscriptionStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreateSubscriptionStmt_default_instance_); } static constexpr int kIndexInFileMessages = 175; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreateSubscriptionStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreateSubscriptionStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreateSubscriptionStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreateSubscriptionStmt& from) { CreateSubscriptionStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreateSubscriptionStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreateSubscriptionStmt"; } protected: explicit CreateSubscriptionStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_publication(); private: const ::pg_query::Node& _internal_publication(int index) const; ::pg_query::Node* _internal_add_publication(); public: const ::pg_query::Node& publication(int index) const; ::pg_query::Node* add_publication(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& publication() const; // repeated .pg_query.Node options = 4 [json_name = "options"]; int options_size() const; private: int _internal_options_size() const; public: void clear_options(); ::pg_query::Node* mutable_options(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // string subname = 1 [json_name = "subname"]; void clear_subname(); const std::string& subname() const; template void set_subname(ArgT0&& arg0, ArgT... args); std::string* mutable_subname(); PROTOBUF_NODISCARD std::string* release_subname(); void set_allocated_subname(std::string* subname); 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 void set_conninfo(ArgT0&& arg0, ArgT... args); std::string* mutable_conninfo(); PROTOBUF_NODISCARD std::string* release_conninfo(); void set_allocated_conninfo(std::string* conninfo); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > publication_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr subname_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conninfo_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterSubscriptionStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterSubscriptionStmt) */ { public: inline AlterSubscriptionStmt() : AlterSubscriptionStmt(nullptr) {} ~AlterSubscriptionStmt() override; explicit PROTOBUF_CONSTEXPR AlterSubscriptionStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterSubscriptionStmt(const AlterSubscriptionStmt& from); AlterSubscriptionStmt(AlterSubscriptionStmt&& from) noexcept : AlterSubscriptionStmt() { *this = ::std::move(from); } inline AlterSubscriptionStmt& operator=(const AlterSubscriptionStmt& from) { CopyFrom(from); return *this; } inline AlterSubscriptionStmt& operator=(AlterSubscriptionStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterSubscriptionStmt_default_instance_); } static constexpr int kIndexInFileMessages = 176; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterSubscriptionStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterSubscriptionStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterSubscriptionStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterSubscriptionStmt& from) { AlterSubscriptionStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterSubscriptionStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterSubscriptionStmt"; } protected: explicit AlterSubscriptionStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_publication(); private: const ::pg_query::Node& _internal_publication(int index) const; ::pg_query::Node* _internal_add_publication(); public: const ::pg_query::Node& publication(int index) const; ::pg_query::Node* add_publication(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& publication() const; // repeated .pg_query.Node options = 5 [json_name = "options"]; int options_size() const; private: int _internal_options_size() const; public: void clear_options(); ::pg_query::Node* mutable_options(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // string subname = 2 [json_name = "subname"]; void clear_subname(); const std::string& subname() const; template void set_subname(ArgT0&& arg0, ArgT... args); std::string* mutable_subname(); PROTOBUF_NODISCARD std::string* release_subname(); void set_allocated_subname(std::string* subname); 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 void set_conninfo(ArgT0&& arg0, ArgT... args); std::string* mutable_conninfo(); PROTOBUF_NODISCARD std::string* release_conninfo(); void set_allocated_conninfo(std::string* conninfo); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > publication_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr subname_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conninfo_; int kind_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class DropSubscriptionStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DropSubscriptionStmt) */ { public: inline DropSubscriptionStmt() : DropSubscriptionStmt(nullptr) {} ~DropSubscriptionStmt() override; explicit PROTOBUF_CONSTEXPR DropSubscriptionStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); DropSubscriptionStmt(const DropSubscriptionStmt& from); DropSubscriptionStmt(DropSubscriptionStmt&& from) noexcept : DropSubscriptionStmt() { *this = ::std::move(from); } inline DropSubscriptionStmt& operator=(const DropSubscriptionStmt& from) { CopyFrom(from); return *this; } inline DropSubscriptionStmt& operator=(DropSubscriptionStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_DropSubscriptionStmt_default_instance_); } static constexpr int kIndexInFileMessages = 177; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(DropSubscriptionStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- DropSubscriptionStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DropSubscriptionStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const DropSubscriptionStmt& from) { DropSubscriptionStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DropSubscriptionStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.DropSubscriptionStmt"; } protected: explicit DropSubscriptionStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_subname(ArgT0&& arg0, ArgT... args); std::string* mutable_subname(); PROTOBUF_NODISCARD std::string* release_subname(); void set_allocated_subname(std::string* subname); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr subname_; bool missing_ok_; int behavior_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreateStatsStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateStatsStmt) */ { public: inline CreateStatsStmt() : CreateStatsStmt(nullptr) {} ~CreateStatsStmt() override; explicit PROTOBUF_CONSTEXPR CreateStatsStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreateStatsStmt(const CreateStatsStmt& from); CreateStatsStmt(CreateStatsStmt&& from) noexcept : CreateStatsStmt() { *this = ::std::move(from); } inline CreateStatsStmt& operator=(const CreateStatsStmt& from) { CopyFrom(from); return *this; } inline CreateStatsStmt& operator=(CreateStatsStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreateStatsStmt_default_instance_); } static constexpr int kIndexInFileMessages = 178; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreateStatsStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreateStatsStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreateStatsStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreateStatsStmt& from) { CreateStatsStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreateStatsStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreateStatsStmt"; } protected: explicit CreateStatsStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_defnames(); private: const ::pg_query::Node& _internal_defnames(int index) const; ::pg_query::Node* _internal_add_defnames(); public: const ::pg_query::Node& defnames(int index) const; ::pg_query::Node* add_defnames(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& defnames() const; // repeated .pg_query.Node stat_types = 2 [json_name = "stat_types"]; int stat_types_size() const; private: int _internal_stat_types_size() const; public: void clear_stat_types(); ::pg_query::Node* mutable_stat_types(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_stat_types(); private: const ::pg_query::Node& _internal_stat_types(int index) const; ::pg_query::Node* _internal_add_stat_types(); public: const ::pg_query::Node& stat_types(int index) const; ::pg_query::Node* add_stat_types(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& stat_types() const; // repeated .pg_query.Node exprs = 3 [json_name = "exprs"]; int exprs_size() const; private: int _internal_exprs_size() const; public: void clear_exprs(); ::pg_query::Node* mutable_exprs(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_exprs(); private: const ::pg_query::Node& _internal_exprs(int index) const; ::pg_query::Node* _internal_add_exprs(); public: const ::pg_query::Node& exprs(int index) const; ::pg_query::Node* add_exprs(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& exprs() const; // repeated .pg_query.Node relations = 4 [json_name = "relations"]; int relations_size() const; private: int _internal_relations_size() const; public: void clear_relations(); ::pg_query::Node* mutable_relations(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_relations(); private: const ::pg_query::Node& _internal_relations(int index) const; ::pg_query::Node* _internal_add_relations(); public: const ::pg_query::Node& relations(int index) const; ::pg_query::Node* add_relations(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& relations() const; // string stxcomment = 5 [json_name = "stxcomment"]; void clear_stxcomment(); const std::string& stxcomment() const; template void set_stxcomment(ArgT0&& arg0, ArgT... args); std::string* mutable_stxcomment(); PROTOBUF_NODISCARD std::string* release_stxcomment(); void set_allocated_stxcomment(std::string* stxcomment); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > defnames_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > stat_types_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > exprs_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > relations_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stxcomment_; bool transformed_; bool if_not_exists_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterCollationStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterCollationStmt) */ { public: inline AlterCollationStmt() : AlterCollationStmt(nullptr) {} ~AlterCollationStmt() override; explicit PROTOBUF_CONSTEXPR AlterCollationStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterCollationStmt(const AlterCollationStmt& from); AlterCollationStmt(AlterCollationStmt&& from) noexcept : AlterCollationStmt() { *this = ::std::move(from); } inline AlterCollationStmt& operator=(const AlterCollationStmt& from) { CopyFrom(from); return *this; } inline AlterCollationStmt& operator=(AlterCollationStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterCollationStmt_default_instance_); } static constexpr int kIndexInFileMessages = 179; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterCollationStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterCollationStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterCollationStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterCollationStmt& from) { AlterCollationStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterCollationStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterCollationStmt"; } protected: explicit AlterCollationStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_collname(); private: const ::pg_query::Node& _internal_collname(int index) const; ::pg_query::Node* _internal_add_collname(); public: const ::pg_query::Node& collname(int index) const; ::pg_query::Node* add_collname(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& collname() const; // @@protoc_insertion_point(class_scope:pg_query.AlterCollationStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > collname_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CallStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CallStmt) */ { public: inline CallStmt() : CallStmt(nullptr) {} ~CallStmt() override; explicit PROTOBUF_CONSTEXPR CallStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CallStmt(const CallStmt& from); CallStmt(CallStmt&& from) noexcept : CallStmt() { *this = ::std::move(from); } inline CallStmt& operator=(const CallStmt& from) { CopyFrom(from); return *this; } inline CallStmt& operator=(CallStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CallStmt_default_instance_); } static constexpr int kIndexInFileMessages = 180; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CallStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CallStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CallStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CallStmt& from) { CallStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CallStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CallStmt"; } protected: explicit CallStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_outargs(); private: const ::pg_query::Node& _internal_outargs(int index) const; ::pg_query::Node* _internal_add_outargs(); public: const ::pg_query::Node& outargs(int index) const; ::pg_query::Node* add_outargs(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& outargs() const; // .pg_query.FuncCall funccall = 1 [json_name = "funccall"]; bool has_funccall() const; private: bool _internal_has_funccall() const; public: void clear_funccall(); const ::pg_query::FuncCall& funccall() const; PROTOBUF_NODISCARD ::pg_query::FuncCall* release_funccall(); ::pg_query::FuncCall* mutable_funccall(); void set_allocated_funccall(::pg_query::FuncCall* funccall); private: const ::pg_query::FuncCall& _internal_funccall() const; ::pg_query::FuncCall* _internal_mutable_funccall(); public: void unsafe_arena_set_allocated_funccall( ::pg_query::FuncCall* funccall); ::pg_query::FuncCall* unsafe_arena_release_funccall(); // .pg_query.FuncExpr funcexpr = 2 [json_name = "funcexpr"]; bool has_funcexpr() const; private: bool _internal_has_funcexpr() const; public: void clear_funcexpr(); const ::pg_query::FuncExpr& funcexpr() const; PROTOBUF_NODISCARD ::pg_query::FuncExpr* release_funcexpr(); ::pg_query::FuncExpr* mutable_funcexpr(); void set_allocated_funcexpr(::pg_query::FuncExpr* funcexpr); private: const ::pg_query::FuncExpr& _internal_funcexpr() const; ::pg_query::FuncExpr* _internal_mutable_funcexpr(); public: void unsafe_arena_set_allocated_funcexpr( ::pg_query::FuncExpr* funcexpr); ::pg_query::FuncExpr* unsafe_arena_release_funcexpr(); // @@protoc_insertion_point(class_scope:pg_query.CallStmt) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > outargs_; ::pg_query::FuncCall* funccall_; ::pg_query::FuncExpr* funcexpr_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AlterStatsStmt final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AlterStatsStmt) */ { public: inline AlterStatsStmt() : AlterStatsStmt(nullptr) {} ~AlterStatsStmt() override; explicit PROTOBUF_CONSTEXPR AlterStatsStmt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AlterStatsStmt(const AlterStatsStmt& from); AlterStatsStmt(AlterStatsStmt&& from) noexcept : AlterStatsStmt() { *this = ::std::move(from); } inline AlterStatsStmt& operator=(const AlterStatsStmt& from) { CopyFrom(from); return *this; } inline AlterStatsStmt& operator=(AlterStatsStmt&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AlterStatsStmt_default_instance_); } static constexpr int kIndexInFileMessages = 181; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AlterStatsStmt* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AlterStatsStmt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AlterStatsStmt& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AlterStatsStmt& from) { AlterStatsStmt::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AlterStatsStmt* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AlterStatsStmt"; } protected: explicit AlterStatsStmt(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_defnames(); private: const ::pg_query::Node& _internal_defnames(int index) const; ::pg_query::Node* _internal_add_defnames(); public: const ::pg_query::Node& defnames(int index) const; ::pg_query::Node* add_defnames(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& defnames() const; // int32 stxstattarget = 2 [json_name = "stxstattarget"]; void clear_stxstattarget(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > defnames_; int32_t stxstattarget_; bool missing_ok_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class A_Expr final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.A_Expr) */ { public: inline A_Expr() : A_Expr(nullptr) {} ~A_Expr() override; explicit PROTOBUF_CONSTEXPR A_Expr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); A_Expr(const A_Expr& from); A_Expr(A_Expr&& from) noexcept : A_Expr() { *this = ::std::move(from); } inline A_Expr& operator=(const A_Expr& from) { CopyFrom(from); return *this; } inline A_Expr& operator=(A_Expr&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_A_Expr_default_instance_); } static constexpr int kIndexInFileMessages = 182; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(A_Expr* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- A_Expr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const A_Expr& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const A_Expr& from) { A_Expr::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(A_Expr* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.A_Expr"; } protected: explicit A_Expr(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_name(); private: const ::pg_query::Node& _internal_name(int index) const; ::pg_query::Node* _internal_add_name(); public: const ::pg_query::Node& name(int index) const; ::pg_query::Node* add_name(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& name() const; // .pg_query.Node lexpr = 3 [json_name = "lexpr"]; bool has_lexpr() const; private: bool _internal_has_lexpr() const; public: void clear_lexpr(); const ::pg_query::Node& lexpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_lexpr(); ::pg_query::Node* mutable_lexpr(); void set_allocated_lexpr(::pg_query::Node* lexpr); private: const ::pg_query::Node& _internal_lexpr() const; ::pg_query::Node* _internal_mutable_lexpr(); public: void unsafe_arena_set_allocated_lexpr( ::pg_query::Node* lexpr); ::pg_query::Node* unsafe_arena_release_lexpr(); // .pg_query.Node rexpr = 4 [json_name = "rexpr"]; bool has_rexpr() const; private: bool _internal_has_rexpr() const; public: void clear_rexpr(); const ::pg_query::Node& rexpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_rexpr(); ::pg_query::Node* mutable_rexpr(); void set_allocated_rexpr(::pg_query::Node* rexpr); private: const ::pg_query::Node& _internal_rexpr() const; ::pg_query::Node* _internal_mutable_rexpr(); public: void unsafe_arena_set_allocated_rexpr( ::pg_query::Node* rexpr); ::pg_query::Node* unsafe_arena_release_rexpr(); // .pg_query.A_Expr_Kind kind = 1 [json_name = "kind"]; void clear_kind(); ::pg_query::A_Expr_Kind kind() const; void set_kind(::pg_query::A_Expr_Kind value); private: ::pg_query::A_Expr_Kind _internal_kind() const; void _internal_set_kind(::pg_query::A_Expr_Kind value); public: // int32 location = 5 [json_name = "location"]; void clear_location(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > name_; ::pg_query::Node* lexpr_; ::pg_query::Node* rexpr_; int kind_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class ColumnRef final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ColumnRef) */ { public: inline ColumnRef() : ColumnRef(nullptr) {} ~ColumnRef() override; explicit PROTOBUF_CONSTEXPR ColumnRef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ColumnRef(const ColumnRef& from); ColumnRef(ColumnRef&& from) noexcept : ColumnRef() { *this = ::std::move(from); } inline ColumnRef& operator=(const ColumnRef& from) { CopyFrom(from); return *this; } inline ColumnRef& operator=(ColumnRef&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_ColumnRef_default_instance_); } static constexpr int kIndexInFileMessages = 183; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ColumnRef* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ColumnRef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ColumnRef& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ColumnRef& from) { ColumnRef::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ColumnRef* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.ColumnRef"; } protected: explicit ColumnRef(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_fields(); private: const ::pg_query::Node& _internal_fields(int index) const; ::pg_query::Node* _internal_add_fields(); public: const ::pg_query::Node& fields(int index) const; ::pg_query::Node* add_fields(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& fields() const; // int32 location = 2 [json_name = "location"]; void clear_location(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > fields_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class ParamRef final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ParamRef) */ { public: inline ParamRef() : ParamRef(nullptr) {} ~ParamRef() override; explicit PROTOBUF_CONSTEXPR ParamRef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ParamRef(const ParamRef& from); ParamRef(ParamRef&& from) noexcept : ParamRef() { *this = ::std::move(from); } inline ParamRef& operator=(const ParamRef& from) { CopyFrom(from); return *this; } inline ParamRef& operator=(ParamRef&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_ParamRef_default_instance_); } static constexpr int kIndexInFileMessages = 184; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ParamRef* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ParamRef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ParamRef& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ParamRef& from) { ParamRef::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ParamRef* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.ParamRef"; } protected: explicit ParamRef(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { int32_t number_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class FuncCall final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.FuncCall) */ { public: inline FuncCall() : FuncCall(nullptr) {} ~FuncCall() override; explicit PROTOBUF_CONSTEXPR FuncCall(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); FuncCall(const FuncCall& from); FuncCall(FuncCall&& from) noexcept : FuncCall() { *this = ::std::move(from); } inline FuncCall& operator=(const FuncCall& from) { CopyFrom(from); return *this; } inline FuncCall& operator=(FuncCall&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_FuncCall_default_instance_); } static constexpr int kIndexInFileMessages = 185; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(FuncCall* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- FuncCall* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const FuncCall& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const FuncCall& from) { FuncCall::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(FuncCall* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.FuncCall"; } protected: explicit FuncCall(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_funcname(); private: const ::pg_query::Node& _internal_funcname(int index) const; ::pg_query::Node* _internal_add_funcname(); public: const ::pg_query::Node& funcname(int index) const; ::pg_query::Node* add_funcname(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& funcname() const; // repeated .pg_query.Node args = 2 [json_name = "args"]; int args_size() const; private: int _internal_args_size() const; public: void clear_args(); ::pg_query::Node* mutable_args(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_args(); private: const ::pg_query::Node& _internal_args(int index) const; ::pg_query::Node* _internal_add_args(); public: const ::pg_query::Node& args(int index) const; ::pg_query::Node* add_args(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& args() const; // repeated .pg_query.Node agg_order = 3 [json_name = "agg_order"]; int agg_order_size() const; private: int _internal_agg_order_size() const; public: void clear_agg_order(); ::pg_query::Node* mutable_agg_order(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_agg_order(); private: const ::pg_query::Node& _internal_agg_order(int index) const; ::pg_query::Node* _internal_add_agg_order(); public: const ::pg_query::Node& agg_order(int index) const; ::pg_query::Node* add_agg_order(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& agg_order() const; // .pg_query.Node agg_filter = 4 [json_name = "agg_filter"]; bool has_agg_filter() const; private: bool _internal_has_agg_filter() const; public: void clear_agg_filter(); const ::pg_query::Node& agg_filter() const; PROTOBUF_NODISCARD ::pg_query::Node* release_agg_filter(); ::pg_query::Node* mutable_agg_filter(); void set_allocated_agg_filter(::pg_query::Node* agg_filter); private: const ::pg_query::Node& _internal_agg_filter() const; ::pg_query::Node* _internal_mutable_agg_filter(); public: void unsafe_arena_set_allocated_agg_filter( ::pg_query::Node* agg_filter); ::pg_query::Node* unsafe_arena_release_agg_filter(); // .pg_query.WindowDef over = 5 [json_name = "over"]; bool has_over() const; private: bool _internal_has_over() const; public: 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* over); private: const ::pg_query::WindowDef& _internal_over() const; ::pg_query::WindowDef* _internal_mutable_over(); public: void unsafe_arena_set_allocated_over( ::pg_query::WindowDef* over); ::pg_query::WindowDef* unsafe_arena_release_over(); // bool agg_within_group = 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > funcname_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > agg_order_; ::pg_query::Node* agg_filter_; ::pg_query::WindowDef* over_; bool agg_within_group_; bool agg_star_; bool agg_distinct_; bool func_variadic_; int funcformat_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class A_Star final : public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:pg_query.A_Star) */ { public: inline A_Star() : A_Star(nullptr) {} explicit PROTOBUF_CONSTEXPR A_Star(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); A_Star(const A_Star& from); A_Star(A_Star&& from) noexcept : A_Star() { *this = ::std::move(from); } inline A_Star& operator=(const A_Star& from) { CopyFrom(from); return *this; } inline A_Star& operator=(A_Star&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_A_Star_default_instance_); } static constexpr int kIndexInFileMessages = 186; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(A_Star* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- A_Star* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom; inline void CopyFrom(const A_Star& from) { ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from); } using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom; void MergeFrom(const A_Star& from) { ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from); } public: private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.A_Star"; } protected: explicit A_Star(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- // @@protoc_insertion_point(class_scope:pg_query.A_Star) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class A_Indices final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.A_Indices) */ { public: inline A_Indices() : A_Indices(nullptr) {} ~A_Indices() override; explicit PROTOBUF_CONSTEXPR A_Indices(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); A_Indices(const A_Indices& from); A_Indices(A_Indices&& from) noexcept : A_Indices() { *this = ::std::move(from); } inline A_Indices& operator=(const A_Indices& from) { CopyFrom(from); return *this; } inline A_Indices& operator=(A_Indices&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_A_Indices_default_instance_); } static constexpr int kIndexInFileMessages = 187; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(A_Indices* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- A_Indices* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const A_Indices& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const A_Indices& from) { A_Indices::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(A_Indices* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.A_Indices"; } protected: explicit A_Indices(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_lidx() const; public: 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* lidx); private: const ::pg_query::Node& _internal_lidx() const; ::pg_query::Node* _internal_mutable_lidx(); public: void unsafe_arena_set_allocated_lidx( ::pg_query::Node* lidx); ::pg_query::Node* unsafe_arena_release_lidx(); // .pg_query.Node uidx = 3 [json_name = "uidx"]; bool has_uidx() const; private: bool _internal_has_uidx() const; public: void clear_uidx(); const ::pg_query::Node& uidx() const; PROTOBUF_NODISCARD ::pg_query::Node* release_uidx(); ::pg_query::Node* mutable_uidx(); void set_allocated_uidx(::pg_query::Node* uidx); private: const ::pg_query::Node& _internal_uidx() const; ::pg_query::Node* _internal_mutable_uidx(); public: void unsafe_arena_set_allocated_uidx( ::pg_query::Node* uidx); ::pg_query::Node* unsafe_arena_release_uidx(); // bool is_slice = 1 [json_name = "is_slice"]; void clear_is_slice(); bool is_slice() const; void set_is_slice(bool value); private: bool _internal_is_slice() const; void _internal_set_is_slice(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.A_Indices) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::Node* lidx_; ::pg_query::Node* uidx_; bool is_slice_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class A_Indirection final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.A_Indirection) */ { public: inline A_Indirection() : A_Indirection(nullptr) {} ~A_Indirection() override; explicit PROTOBUF_CONSTEXPR A_Indirection(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); A_Indirection(const A_Indirection& from); A_Indirection(A_Indirection&& from) noexcept : A_Indirection() { *this = ::std::move(from); } inline A_Indirection& operator=(const A_Indirection& from) { CopyFrom(from); return *this; } inline A_Indirection& operator=(A_Indirection&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_A_Indirection_default_instance_); } static constexpr int kIndexInFileMessages = 188; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(A_Indirection* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- A_Indirection* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const A_Indirection& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const A_Indirection& from) { A_Indirection::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(A_Indirection* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.A_Indirection"; } protected: explicit A_Indirection(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_indirection(); private: const ::pg_query::Node& _internal_indirection(int index) const; ::pg_query::Node* _internal_add_indirection(); public: const ::pg_query::Node& indirection(int index) const; ::pg_query::Node* add_indirection(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& indirection() const; // .pg_query.Node arg = 1 [json_name = "arg"]; bool has_arg() const; private: bool _internal_has_arg() const; public: void clear_arg(); const ::pg_query::Node& arg() const; PROTOBUF_NODISCARD ::pg_query::Node* release_arg(); ::pg_query::Node* mutable_arg(); void set_allocated_arg(::pg_query::Node* arg); private: const ::pg_query::Node& _internal_arg() const; ::pg_query::Node* _internal_mutable_arg(); public: void unsafe_arena_set_allocated_arg( ::pg_query::Node* arg); ::pg_query::Node* unsafe_arena_release_arg(); // @@protoc_insertion_point(class_scope:pg_query.A_Indirection) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > indirection_; ::pg_query::Node* arg_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class A_ArrayExpr final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.A_ArrayExpr) */ { public: inline A_ArrayExpr() : A_ArrayExpr(nullptr) {} ~A_ArrayExpr() override; explicit PROTOBUF_CONSTEXPR A_ArrayExpr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); A_ArrayExpr(const A_ArrayExpr& from); A_ArrayExpr(A_ArrayExpr&& from) noexcept : A_ArrayExpr() { *this = ::std::move(from); } inline A_ArrayExpr& operator=(const A_ArrayExpr& from) { CopyFrom(from); return *this; } inline A_ArrayExpr& operator=(A_ArrayExpr&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_A_ArrayExpr_default_instance_); } static constexpr int kIndexInFileMessages = 189; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(A_ArrayExpr* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- A_ArrayExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const A_ArrayExpr& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const A_ArrayExpr& from) { A_ArrayExpr::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(A_ArrayExpr* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.A_ArrayExpr"; } protected: explicit A_ArrayExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_elements(); private: const ::pg_query::Node& _internal_elements(int index) const; ::pg_query::Node* _internal_add_elements(); public: const ::pg_query::Node& elements(int index) const; ::pg_query::Node* add_elements(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& elements() const; // int32 location = 2 [json_name = "location"]; void clear_location(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > elements_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class ResTarget final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ResTarget) */ { public: inline ResTarget() : ResTarget(nullptr) {} ~ResTarget() override; explicit PROTOBUF_CONSTEXPR ResTarget(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ResTarget(const ResTarget& from); ResTarget(ResTarget&& from) noexcept : ResTarget() { *this = ::std::move(from); } inline ResTarget& operator=(const ResTarget& from) { CopyFrom(from); return *this; } inline ResTarget& operator=(ResTarget&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_ResTarget_default_instance_); } static constexpr int kIndexInFileMessages = 190; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ResTarget* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ResTarget* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ResTarget& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ResTarget& from) { ResTarget::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ResTarget* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.ResTarget"; } protected: explicit ResTarget(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_indirection(); private: const ::pg_query::Node& _internal_indirection(int index) const; ::pg_query::Node* _internal_add_indirection(); public: const ::pg_query::Node& indirection(int index) const; ::pg_query::Node* add_indirection(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& indirection() const; // string name = 1 [json_name = "name"]; void clear_name(); const std::string& name() const; template void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); 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; private: bool _internal_has_val() const; public: 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* val); private: const ::pg_query::Node& _internal_val() const; ::pg_query::Node* _internal_mutable_val(); public: void unsafe_arena_set_allocated_val( ::pg_query::Node* val); ::pg_query::Node* unsafe_arena_release_val(); // int32 location = 4 [json_name = "location"]; void clear_location(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > indirection_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; ::pg_query::Node* val_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class MultiAssignRef final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.MultiAssignRef) */ { public: inline MultiAssignRef() : MultiAssignRef(nullptr) {} ~MultiAssignRef() override; explicit PROTOBUF_CONSTEXPR MultiAssignRef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); MultiAssignRef(const MultiAssignRef& from); MultiAssignRef(MultiAssignRef&& from) noexcept : MultiAssignRef() { *this = ::std::move(from); } inline MultiAssignRef& operator=(const MultiAssignRef& from) { CopyFrom(from); return *this; } inline MultiAssignRef& operator=(MultiAssignRef&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_MultiAssignRef_default_instance_); } static constexpr int kIndexInFileMessages = 191; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(MultiAssignRef* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- MultiAssignRef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const MultiAssignRef& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const MultiAssignRef& from) { MultiAssignRef::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(MultiAssignRef* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.MultiAssignRef"; } protected: explicit MultiAssignRef(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_source() const; public: 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* source); private: const ::pg_query::Node& _internal_source() const; ::pg_query::Node* _internal_mutable_source(); public: void unsafe_arena_set_allocated_source( ::pg_query::Node* source); ::pg_query::Node* unsafe_arena_release_source(); // int32 colno = 2 [json_name = "colno"]; void clear_colno(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::Node* source_; int32_t colno_; int32_t ncolumns_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class TypeCast final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.TypeCast) */ { public: inline TypeCast() : TypeCast(nullptr) {} ~TypeCast() override; explicit PROTOBUF_CONSTEXPR TypeCast(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); TypeCast(const TypeCast& from); TypeCast(TypeCast&& from) noexcept : TypeCast() { *this = ::std::move(from); } inline TypeCast& operator=(const TypeCast& from) { CopyFrom(from); return *this; } inline TypeCast& operator=(TypeCast&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_TypeCast_default_instance_); } static constexpr int kIndexInFileMessages = 192; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(TypeCast* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- TypeCast* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const TypeCast& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const TypeCast& from) { TypeCast::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(TypeCast* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.TypeCast"; } protected: explicit TypeCast(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_arg() const; public: 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* arg); private: const ::pg_query::Node& _internal_arg() const; ::pg_query::Node* _internal_mutable_arg(); public: void unsafe_arena_set_allocated_arg( ::pg_query::Node* arg); ::pg_query::Node* unsafe_arena_release_arg(); // .pg_query.TypeName type_name = 2 [json_name = "typeName"]; bool has_type_name() const; private: bool _internal_has_type_name() const; public: void clear_type_name(); const ::pg_query::TypeName& type_name() const; PROTOBUF_NODISCARD ::pg_query::TypeName* release_type_name(); ::pg_query::TypeName* mutable_type_name(); void set_allocated_type_name(::pg_query::TypeName* type_name); private: const ::pg_query::TypeName& _internal_type_name() const; ::pg_query::TypeName* _internal_mutable_type_name(); public: void unsafe_arena_set_allocated_type_name( ::pg_query::TypeName* type_name); ::pg_query::TypeName* unsafe_arena_release_type_name(); // int32 location = 3 [json_name = "location"]; void clear_location(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::Node* arg_; ::pg_query::TypeName* type_name_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CollateClause final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CollateClause) */ { public: inline CollateClause() : CollateClause(nullptr) {} ~CollateClause() override; explicit PROTOBUF_CONSTEXPR CollateClause(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CollateClause(const CollateClause& from); CollateClause(CollateClause&& from) noexcept : CollateClause() { *this = ::std::move(from); } inline CollateClause& operator=(const CollateClause& from) { CopyFrom(from); return *this; } inline CollateClause& operator=(CollateClause&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CollateClause_default_instance_); } static constexpr int kIndexInFileMessages = 193; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CollateClause* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CollateClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CollateClause& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CollateClause& from) { CollateClause::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CollateClause* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CollateClause"; } protected: explicit CollateClause(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_collname(); private: const ::pg_query::Node& _internal_collname(int index) const; ::pg_query::Node* _internal_add_collname(); public: const ::pg_query::Node& collname(int index) const; ::pg_query::Node* add_collname(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& collname() const; // .pg_query.Node arg = 1 [json_name = "arg"]; bool has_arg() const; private: bool _internal_has_arg() const; public: void clear_arg(); const ::pg_query::Node& arg() const; PROTOBUF_NODISCARD ::pg_query::Node* release_arg(); ::pg_query::Node* mutable_arg(); void set_allocated_arg(::pg_query::Node* arg); private: const ::pg_query::Node& _internal_arg() const; ::pg_query::Node* _internal_mutable_arg(); public: void unsafe_arena_set_allocated_arg( ::pg_query::Node* arg); ::pg_query::Node* unsafe_arena_release_arg(); // int32 location = 3 [json_name = "location"]; void clear_location(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > collname_; ::pg_query::Node* arg_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class SortBy final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.SortBy) */ { public: inline SortBy() : SortBy(nullptr) {} ~SortBy() override; explicit PROTOBUF_CONSTEXPR SortBy(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); SortBy(const SortBy& from); SortBy(SortBy&& from) noexcept : SortBy() { *this = ::std::move(from); } inline SortBy& operator=(const SortBy& from) { CopyFrom(from); return *this; } inline SortBy& operator=(SortBy&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_SortBy_default_instance_); } static constexpr int kIndexInFileMessages = 194; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SortBy* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- SortBy* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const SortBy& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const SortBy& from) { SortBy::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(SortBy* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.SortBy"; } protected: explicit SortBy(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_use_op(); private: const ::pg_query::Node& _internal_use_op(int index) const; ::pg_query::Node* _internal_add_use_op(); public: const ::pg_query::Node& use_op(int index) const; ::pg_query::Node* add_use_op(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& use_op() const; // .pg_query.Node node = 1 [json_name = "node"]; bool has_node() const; private: bool _internal_has_node() const; public: void clear_node(); const ::pg_query::Node& node() const; PROTOBUF_NODISCARD ::pg_query::Node* release_node(); ::pg_query::Node* mutable_node(); void set_allocated_node(::pg_query::Node* node); private: const ::pg_query::Node& _internal_node() const; ::pg_query::Node* _internal_mutable_node(); public: void unsafe_arena_set_allocated_node( ::pg_query::Node* node); ::pg_query::Node* unsafe_arena_release_node(); // .pg_query.SortByDir sortby_dir = 2 [json_name = "sortby_dir"]; void clear_sortby_dir(); ::pg_query::SortByDir sortby_dir() const; void set_sortby_dir(::pg_query::SortByDir value); private: ::pg_query::SortByDir _internal_sortby_dir() const; void _internal_set_sortby_dir(::pg_query::SortByDir value); public: // .pg_query.SortByNulls sortby_nulls = 3 [json_name = "sortby_nulls"]; void clear_sortby_nulls(); ::pg_query::SortByNulls sortby_nulls() const; void set_sortby_nulls(::pg_query::SortByNulls value); private: ::pg_query::SortByNulls _internal_sortby_nulls() const; void _internal_set_sortby_nulls(::pg_query::SortByNulls value); public: // int32 location = 5 [json_name = "location"]; void clear_location(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > use_op_; ::pg_query::Node* node_; int sortby_dir_; int sortby_nulls_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class WindowDef final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.WindowDef) */ { public: inline WindowDef() : WindowDef(nullptr) {} ~WindowDef() override; explicit PROTOBUF_CONSTEXPR WindowDef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); WindowDef(const WindowDef& from); WindowDef(WindowDef&& from) noexcept : WindowDef() { *this = ::std::move(from); } inline WindowDef& operator=(const WindowDef& from) { CopyFrom(from); return *this; } inline WindowDef& operator=(WindowDef&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_WindowDef_default_instance_); } static constexpr int kIndexInFileMessages = 195; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(WindowDef* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- WindowDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const WindowDef& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const WindowDef& from) { WindowDef::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(WindowDef* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.WindowDef"; } protected: explicit WindowDef(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_partition_clause(); private: const ::pg_query::Node& _internal_partition_clause(int index) const; ::pg_query::Node* _internal_add_partition_clause(); public: const ::pg_query::Node& partition_clause(int index) const; ::pg_query::Node* add_partition_clause(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& partition_clause() const; // repeated .pg_query.Node order_clause = 4 [json_name = "orderClause"]; int order_clause_size() const; private: int _internal_order_clause_size() const; public: void clear_order_clause(); ::pg_query::Node* mutable_order_clause(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_order_clause(); private: const ::pg_query::Node& _internal_order_clause(int index) const; ::pg_query::Node* _internal_add_order_clause(); public: const ::pg_query::Node& order_clause(int index) const; ::pg_query::Node* add_order_clause(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& order_clause() const; // string name = 1 [json_name = "name"]; void clear_name(); const std::string& name() const; template void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); 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 void set_refname(ArgT0&& arg0, ArgT... args); std::string* mutable_refname(); PROTOBUF_NODISCARD std::string* release_refname(); void set_allocated_refname(std::string* refname); 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; private: bool _internal_has_start_offset() const; public: 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* start_offset); private: const ::pg_query::Node& _internal_start_offset() const; ::pg_query::Node* _internal_mutable_start_offset(); public: void unsafe_arena_set_allocated_start_offset( ::pg_query::Node* start_offset); ::pg_query::Node* unsafe_arena_release_start_offset(); // .pg_query.Node end_offset = 7 [json_name = "endOffset"]; bool has_end_offset() const; private: bool _internal_has_end_offset() const; public: void clear_end_offset(); const ::pg_query::Node& end_offset() const; PROTOBUF_NODISCARD ::pg_query::Node* release_end_offset(); ::pg_query::Node* mutable_end_offset(); void set_allocated_end_offset(::pg_query::Node* end_offset); private: const ::pg_query::Node& _internal_end_offset() const; ::pg_query::Node* _internal_mutable_end_offset(); public: void unsafe_arena_set_allocated_end_offset( ::pg_query::Node* end_offset); ::pg_query::Node* unsafe_arena_release_end_offset(); // int32 frame_options = 5 [json_name = "frameOptions"]; void clear_frame_options(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > partition_clause_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > order_clause_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr refname_; ::pg_query::Node* start_offset_; ::pg_query::Node* end_offset_; int32_t frame_options_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class RangeSubselect final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RangeSubselect) */ { public: inline RangeSubselect() : RangeSubselect(nullptr) {} ~RangeSubselect() override; explicit PROTOBUF_CONSTEXPR RangeSubselect(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); RangeSubselect(const RangeSubselect& from); RangeSubselect(RangeSubselect&& from) noexcept : RangeSubselect() { *this = ::std::move(from); } inline RangeSubselect& operator=(const RangeSubselect& from) { CopyFrom(from); return *this; } inline RangeSubselect& operator=(RangeSubselect&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_RangeSubselect_default_instance_); } static constexpr int kIndexInFileMessages = 196; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(RangeSubselect* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- RangeSubselect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const RangeSubselect& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const RangeSubselect& from) { RangeSubselect::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(RangeSubselect* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.RangeSubselect"; } protected: explicit RangeSubselect(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_subquery() const; public: 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* subquery); private: const ::pg_query::Node& _internal_subquery() const; ::pg_query::Node* _internal_mutable_subquery(); public: void unsafe_arena_set_allocated_subquery( ::pg_query::Node* subquery); ::pg_query::Node* unsafe_arena_release_subquery(); // .pg_query.Alias alias = 3 [json_name = "alias"]; bool has_alias() const; private: bool _internal_has_alias() const; public: void clear_alias(); const ::pg_query::Alias& alias() const; PROTOBUF_NODISCARD ::pg_query::Alias* release_alias(); ::pg_query::Alias* mutable_alias(); void set_allocated_alias(::pg_query::Alias* alias); private: const ::pg_query::Alias& _internal_alias() const; ::pg_query::Alias* _internal_mutable_alias(); public: void unsafe_arena_set_allocated_alias( ::pg_query::Alias* alias); ::pg_query::Alias* unsafe_arena_release_alias(); // bool lateral = 1 [json_name = "lateral"]; void clear_lateral(); bool lateral() const; void set_lateral(bool value); private: bool _internal_lateral() const; void _internal_set_lateral(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.RangeSubselect) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::Node* subquery_; ::pg_query::Alias* alias_; bool lateral_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class RangeFunction final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RangeFunction) */ { public: inline RangeFunction() : RangeFunction(nullptr) {} ~RangeFunction() override; explicit PROTOBUF_CONSTEXPR RangeFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); RangeFunction(const RangeFunction& from); RangeFunction(RangeFunction&& from) noexcept : RangeFunction() { *this = ::std::move(from); } inline RangeFunction& operator=(const RangeFunction& from) { CopyFrom(from); return *this; } inline RangeFunction& operator=(RangeFunction&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_RangeFunction_default_instance_); } static constexpr int kIndexInFileMessages = 197; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(RangeFunction* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- RangeFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const RangeFunction& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const RangeFunction& from) { RangeFunction::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(RangeFunction* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.RangeFunction"; } protected: explicit RangeFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_functions(); private: const ::pg_query::Node& _internal_functions(int index) const; ::pg_query::Node* _internal_add_functions(); public: const ::pg_query::Node& functions(int index) const; ::pg_query::Node* add_functions(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& functions() const; // repeated .pg_query.Node coldeflist = 6 [json_name = "coldeflist"]; int coldeflist_size() const; private: int _internal_coldeflist_size() const; public: void clear_coldeflist(); ::pg_query::Node* mutable_coldeflist(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_coldeflist(); private: const ::pg_query::Node& _internal_coldeflist(int index) const; ::pg_query::Node* _internal_add_coldeflist(); public: const ::pg_query::Node& coldeflist(int index) const; ::pg_query::Node* add_coldeflist(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& coldeflist() const; // .pg_query.Alias alias = 5 [json_name = "alias"]; bool has_alias() const; private: bool _internal_has_alias() const; public: void clear_alias(); const ::pg_query::Alias& alias() const; PROTOBUF_NODISCARD ::pg_query::Alias* release_alias(); ::pg_query::Alias* mutable_alias(); void set_allocated_alias(::pg_query::Alias* alias); private: const ::pg_query::Alias& _internal_alias() const; ::pg_query::Alias* _internal_mutable_alias(); public: void unsafe_arena_set_allocated_alias( ::pg_query::Alias* alias); ::pg_query::Alias* unsafe_arena_release_alias(); // bool lateral = 1 [json_name = "lateral"]; void clear_lateral(); bool lateral() const; void set_lateral(bool value); private: bool _internal_lateral() const; void _internal_set_lateral(bool value); public: // bool ordinality = 2 [json_name = "ordinality"]; void clear_ordinality(); bool ordinality() const; void set_ordinality(bool value); private: bool _internal_ordinality() const; void _internal_set_ordinality(bool value); public: // bool is_rowsfrom = 3 [json_name = "is_rowsfrom"]; void clear_is_rowsfrom(); bool is_rowsfrom() const; void set_is_rowsfrom(bool value); private: bool _internal_is_rowsfrom() const; void _internal_set_is_rowsfrom(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.RangeFunction) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > functions_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > coldeflist_; ::pg_query::Alias* alias_; bool lateral_; bool ordinality_; bool is_rowsfrom_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class RangeTableSample final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RangeTableSample) */ { public: inline RangeTableSample() : RangeTableSample(nullptr) {} ~RangeTableSample() override; explicit PROTOBUF_CONSTEXPR RangeTableSample(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); RangeTableSample(const RangeTableSample& from); RangeTableSample(RangeTableSample&& from) noexcept : RangeTableSample() { *this = ::std::move(from); } inline RangeTableSample& operator=(const RangeTableSample& from) { CopyFrom(from); return *this; } inline RangeTableSample& operator=(RangeTableSample&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_RangeTableSample_default_instance_); } static constexpr int kIndexInFileMessages = 198; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(RangeTableSample* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- RangeTableSample* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const RangeTableSample& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const RangeTableSample& from) { RangeTableSample::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(RangeTableSample* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.RangeTableSample"; } protected: explicit RangeTableSample(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_method(); private: const ::pg_query::Node& _internal_method(int index) const; ::pg_query::Node* _internal_add_method(); public: const ::pg_query::Node& method(int index) const; ::pg_query::Node* add_method(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& method() const; // repeated .pg_query.Node args = 3 [json_name = "args"]; int args_size() const; private: int _internal_args_size() const; public: void clear_args(); ::pg_query::Node* mutable_args(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_args(); private: const ::pg_query::Node& _internal_args(int index) const; ::pg_query::Node* _internal_add_args(); public: const ::pg_query::Node& args(int index) const; ::pg_query::Node* add_args(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& args() const; // .pg_query.Node relation = 1 [json_name = "relation"]; bool has_relation() const; private: bool _internal_has_relation() const; public: void clear_relation(); const ::pg_query::Node& relation() const; PROTOBUF_NODISCARD ::pg_query::Node* release_relation(); ::pg_query::Node* mutable_relation(); void set_allocated_relation(::pg_query::Node* relation); private: const ::pg_query::Node& _internal_relation() const; ::pg_query::Node* _internal_mutable_relation(); public: void unsafe_arena_set_allocated_relation( ::pg_query::Node* relation); ::pg_query::Node* unsafe_arena_release_relation(); // .pg_query.Node repeatable = 4 [json_name = "repeatable"]; bool has_repeatable() const; private: bool _internal_has_repeatable() const; public: void clear_repeatable(); const ::pg_query::Node& repeatable() const; PROTOBUF_NODISCARD ::pg_query::Node* release_repeatable(); ::pg_query::Node* mutable_repeatable(); void set_allocated_repeatable(::pg_query::Node* repeatable); private: const ::pg_query::Node& _internal_repeatable() const; ::pg_query::Node* _internal_mutable_repeatable(); public: void unsafe_arena_set_allocated_repeatable( ::pg_query::Node* repeatable); ::pg_query::Node* unsafe_arena_release_repeatable(); // int32 location = 5 [json_name = "location"]; void clear_location(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > method_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_; ::pg_query::Node* relation_; ::pg_query::Node* repeatable_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class RangeTableFunc final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RangeTableFunc) */ { public: inline RangeTableFunc() : RangeTableFunc(nullptr) {} ~RangeTableFunc() override; explicit PROTOBUF_CONSTEXPR RangeTableFunc(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); RangeTableFunc(const RangeTableFunc& from); RangeTableFunc(RangeTableFunc&& from) noexcept : RangeTableFunc() { *this = ::std::move(from); } inline RangeTableFunc& operator=(const RangeTableFunc& from) { CopyFrom(from); return *this; } inline RangeTableFunc& operator=(RangeTableFunc&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_RangeTableFunc_default_instance_); } static constexpr int kIndexInFileMessages = 199; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(RangeTableFunc* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- RangeTableFunc* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const RangeTableFunc& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const RangeTableFunc& from) { RangeTableFunc::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(RangeTableFunc* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.RangeTableFunc"; } protected: explicit RangeTableFunc(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_namespaces(); private: const ::pg_query::Node& _internal_namespaces(int index) const; ::pg_query::Node* _internal_add_namespaces(); public: const ::pg_query::Node& namespaces(int index) const; ::pg_query::Node* add_namespaces(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& namespaces() const; // repeated .pg_query.Node columns = 5 [json_name = "columns"]; int columns_size() const; private: int _internal_columns_size() const; public: void clear_columns(); ::pg_query::Node* mutable_columns(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_columns(); private: const ::pg_query::Node& _internal_columns(int index) const; ::pg_query::Node* _internal_add_columns(); public: const ::pg_query::Node& columns(int index) const; ::pg_query::Node* add_columns(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& columns() const; // .pg_query.Node docexpr = 2 [json_name = "docexpr"]; bool has_docexpr() const; private: bool _internal_has_docexpr() const; public: void clear_docexpr(); const ::pg_query::Node& docexpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_docexpr(); ::pg_query::Node* mutable_docexpr(); void set_allocated_docexpr(::pg_query::Node* docexpr); private: const ::pg_query::Node& _internal_docexpr() const; ::pg_query::Node* _internal_mutable_docexpr(); public: void unsafe_arena_set_allocated_docexpr( ::pg_query::Node* docexpr); ::pg_query::Node* unsafe_arena_release_docexpr(); // .pg_query.Node rowexpr = 3 [json_name = "rowexpr"]; bool has_rowexpr() const; private: bool _internal_has_rowexpr() const; public: void clear_rowexpr(); const ::pg_query::Node& rowexpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_rowexpr(); ::pg_query::Node* mutable_rowexpr(); void set_allocated_rowexpr(::pg_query::Node* rowexpr); private: const ::pg_query::Node& _internal_rowexpr() const; ::pg_query::Node* _internal_mutable_rowexpr(); public: void unsafe_arena_set_allocated_rowexpr( ::pg_query::Node* rowexpr); ::pg_query::Node* unsafe_arena_release_rowexpr(); // .pg_query.Alias alias = 6 [json_name = "alias"]; bool has_alias() const; private: bool _internal_has_alias() const; public: void clear_alias(); const ::pg_query::Alias& alias() const; PROTOBUF_NODISCARD ::pg_query::Alias* release_alias(); ::pg_query::Alias* mutable_alias(); void set_allocated_alias(::pg_query::Alias* alias); private: const ::pg_query::Alias& _internal_alias() const; ::pg_query::Alias* _internal_mutable_alias(); public: void unsafe_arena_set_allocated_alias( ::pg_query::Alias* alias); ::pg_query::Alias* unsafe_arena_release_alias(); // bool lateral = 1 [json_name = "lateral"]; void clear_lateral(); bool lateral() const; void set_lateral(bool value); private: bool _internal_lateral() const; void _internal_set_lateral(bool value); public: // int32 location = 7 [json_name = "location"]; void clear_location(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > namespaces_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > columns_; ::pg_query::Node* docexpr_; ::pg_query::Node* rowexpr_; ::pg_query::Alias* alias_; bool lateral_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class RangeTableFuncCol final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RangeTableFuncCol) */ { public: inline RangeTableFuncCol() : RangeTableFuncCol(nullptr) {} ~RangeTableFuncCol() override; explicit PROTOBUF_CONSTEXPR RangeTableFuncCol(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); RangeTableFuncCol(const RangeTableFuncCol& from); RangeTableFuncCol(RangeTableFuncCol&& from) noexcept : RangeTableFuncCol() { *this = ::std::move(from); } inline RangeTableFuncCol& operator=(const RangeTableFuncCol& from) { CopyFrom(from); return *this; } inline RangeTableFuncCol& operator=(RangeTableFuncCol&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_RangeTableFuncCol_default_instance_); } static constexpr int kIndexInFileMessages = 200; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(RangeTableFuncCol* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- RangeTableFuncCol* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const RangeTableFuncCol& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const RangeTableFuncCol& from) { RangeTableFuncCol::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(RangeTableFuncCol* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.RangeTableFuncCol"; } protected: explicit RangeTableFuncCol(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_colname(ArgT0&& arg0, ArgT... args); std::string* mutable_colname(); PROTOBUF_NODISCARD std::string* release_colname(); void set_allocated_colname(std::string* colname); 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; 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* type_name); private: const ::pg_query::TypeName& _internal_type_name() const; ::pg_query::TypeName* _internal_mutable_type_name(); public: void unsafe_arena_set_allocated_type_name( ::pg_query::TypeName* type_name); ::pg_query::TypeName* unsafe_arena_release_type_name(); // .pg_query.Node colexpr = 5 [json_name = "colexpr"]; bool has_colexpr() const; private: bool _internal_has_colexpr() const; public: void clear_colexpr(); const ::pg_query::Node& colexpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_colexpr(); ::pg_query::Node* mutable_colexpr(); void set_allocated_colexpr(::pg_query::Node* colexpr); private: const ::pg_query::Node& _internal_colexpr() const; ::pg_query::Node* _internal_mutable_colexpr(); public: void unsafe_arena_set_allocated_colexpr( ::pg_query::Node* colexpr); ::pg_query::Node* unsafe_arena_release_colexpr(); // .pg_query.Node coldefexpr = 6 [json_name = "coldefexpr"]; bool has_coldefexpr() const; private: bool _internal_has_coldefexpr() const; public: void clear_coldefexpr(); const ::pg_query::Node& coldefexpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_coldefexpr(); ::pg_query::Node* mutable_coldefexpr(); void set_allocated_coldefexpr(::pg_query::Node* coldefexpr); private: const ::pg_query::Node& _internal_coldefexpr() const; ::pg_query::Node* _internal_mutable_coldefexpr(); public: void unsafe_arena_set_allocated_coldefexpr( ::pg_query::Node* coldefexpr); ::pg_query::Node* unsafe_arena_release_coldefexpr(); // bool for_ordinality = 3 [json_name = "for_ordinality"]; void clear_for_ordinality(); bool for_ordinality() const; void set_for_ordinality(bool value); private: bool _internal_for_ordinality() const; void _internal_set_for_ordinality(bool value); public: // bool is_not_null = 4 [json_name = "is_not_null"]; void clear_is_not_null(); bool is_not_null() const; void set_is_not_null(bool value); private: bool _internal_is_not_null() const; void _internal_set_is_not_null(bool value); public: // int32 location = 7 [json_name = "location"]; void clear_location(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr colname_; ::pg_query::TypeName* type_name_; ::pg_query::Node* colexpr_; ::pg_query::Node* coldefexpr_; bool for_ordinality_; bool is_not_null_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class TypeName final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.TypeName) */ { public: inline TypeName() : TypeName(nullptr) {} ~TypeName() override; explicit PROTOBUF_CONSTEXPR TypeName(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); TypeName(const TypeName& from); TypeName(TypeName&& from) noexcept : TypeName() { *this = ::std::move(from); } inline TypeName& operator=(const TypeName& from) { CopyFrom(from); return *this; } inline TypeName& operator=(TypeName&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_TypeName_default_instance_); } static constexpr int kIndexInFileMessages = 201; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(TypeName* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- TypeName* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const TypeName& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const TypeName& from) { TypeName::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(TypeName* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.TypeName"; } protected: explicit TypeName(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_names(); private: const ::pg_query::Node& _internal_names(int index) const; ::pg_query::Node* _internal_add_names(); public: const ::pg_query::Node& names(int index) const; ::pg_query::Node* add_names(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& names() const; // repeated .pg_query.Node typmods = 5 [json_name = "typmods"]; int typmods_size() const; private: int _internal_typmods_size() const; public: void clear_typmods(); ::pg_query::Node* mutable_typmods(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_typmods(); private: const ::pg_query::Node& _internal_typmods(int index) const; ::pg_query::Node* _internal_add_typmods(); public: const ::pg_query::Node& typmods(int index) const; ::pg_query::Node* add_typmods(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& typmods() const; // repeated .pg_query.Node array_bounds = 7 [json_name = "arrayBounds"]; int array_bounds_size() const; private: int _internal_array_bounds_size() const; public: void clear_array_bounds(); ::pg_query::Node* mutable_array_bounds(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_array_bounds(); private: const ::pg_query::Node& _internal_array_bounds(int index) const; ::pg_query::Node* _internal_add_array_bounds(); public: const ::pg_query::Node& array_bounds(int index) const; ::pg_query::Node* add_array_bounds(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& array_bounds() const; // uint32 type_oid = 2 [json_name = "typeOid"]; void clear_type_oid(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > names_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > typmods_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > array_bounds_; uint32_t type_oid_; bool setof_; bool pct_type_; int32_t typemod_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class ColumnDef final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ColumnDef) */ { public: inline ColumnDef() : ColumnDef(nullptr) {} ~ColumnDef() override; explicit PROTOBUF_CONSTEXPR ColumnDef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ColumnDef(const ColumnDef& from); ColumnDef(ColumnDef&& from) noexcept : ColumnDef() { *this = ::std::move(from); } inline ColumnDef& operator=(const ColumnDef& from) { CopyFrom(from); return *this; } inline ColumnDef& operator=(ColumnDef&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_ColumnDef_default_instance_); } static constexpr int kIndexInFileMessages = 202; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ColumnDef* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ColumnDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ColumnDef& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ColumnDef& from) { ColumnDef::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ColumnDef* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.ColumnDef"; } protected: explicit ColumnDef(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kConstraintsFieldNumber = 16, kFdwoptionsFieldNumber = 17, kColnameFieldNumber = 1, kCompressionFieldNumber = 3, kStorageFieldNumber = 8, kIdentityFieldNumber = 11, kGeneratedFieldNumber = 13, kTypeNameFieldNumber = 2, kRawDefaultFieldNumber = 9, kCookedDefaultFieldNumber = 10, kIdentitySequenceFieldNumber = 12, kCollClauseFieldNumber = 14, kInhcountFieldNumber = 4, kIsLocalFieldNumber = 5, kIsNotNullFieldNumber = 6, kIsFromTypeFieldNumber = 7, kCollOidFieldNumber = 15, kLocationFieldNumber = 18, }; // repeated .pg_query.Node constraints = 16 [json_name = "constraints"]; int constraints_size() const; private: int _internal_constraints_size() const; public: void clear_constraints(); ::pg_query::Node* mutable_constraints(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_constraints(); private: const ::pg_query::Node& _internal_constraints(int index) const; ::pg_query::Node* _internal_add_constraints(); public: const ::pg_query::Node& constraints(int index) const; ::pg_query::Node* add_constraints(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& constraints() const; // repeated .pg_query.Node fdwoptions = 17 [json_name = "fdwoptions"]; int fdwoptions_size() const; private: int _internal_fdwoptions_size() const; public: void clear_fdwoptions(); ::pg_query::Node* mutable_fdwoptions(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_fdwoptions(); private: const ::pg_query::Node& _internal_fdwoptions(int index) const; ::pg_query::Node* _internal_add_fdwoptions(); public: const ::pg_query::Node& fdwoptions(int index) const; ::pg_query::Node* add_fdwoptions(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& fdwoptions() const; // string colname = 1 [json_name = "colname"]; void clear_colname(); const std::string& colname() const; template void set_colname(ArgT0&& arg0, ArgT... args); std::string* mutable_colname(); PROTOBUF_NODISCARD std::string* release_colname(); void set_allocated_colname(std::string* colname); 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 void set_compression(ArgT0&& arg0, ArgT... args); std::string* mutable_compression(); PROTOBUF_NODISCARD std::string* release_compression(); void set_allocated_compression(std::string* compression); 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 void set_storage(ArgT0&& arg0, ArgT... args); std::string* mutable_storage(); PROTOBUF_NODISCARD std::string* release_storage(); void set_allocated_storage(std::string* storage); 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 identity = 11 [json_name = "identity"]; void clear_identity(); const std::string& identity() const; template void set_identity(ArgT0&& arg0, ArgT... args); std::string* mutable_identity(); PROTOBUF_NODISCARD std::string* release_identity(); void set_allocated_identity(std::string* identity); 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 = 13 [json_name = "generated"]; void clear_generated(); const std::string& generated() const; template void set_generated(ArgT0&& arg0, ArgT... args); std::string* mutable_generated(); PROTOBUF_NODISCARD std::string* release_generated(); void set_allocated_generated(std::string* generated); 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; 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* type_name); private: const ::pg_query::TypeName& _internal_type_name() const; ::pg_query::TypeName* _internal_mutable_type_name(); public: void unsafe_arena_set_allocated_type_name( ::pg_query::TypeName* type_name); ::pg_query::TypeName* unsafe_arena_release_type_name(); // .pg_query.Node raw_default = 9 [json_name = "raw_default"]; bool has_raw_default() const; private: bool _internal_has_raw_default() const; public: void clear_raw_default(); const ::pg_query::Node& raw_default() const; PROTOBUF_NODISCARD ::pg_query::Node* release_raw_default(); ::pg_query::Node* mutable_raw_default(); void set_allocated_raw_default(::pg_query::Node* raw_default); private: const ::pg_query::Node& _internal_raw_default() const; ::pg_query::Node* _internal_mutable_raw_default(); public: void unsafe_arena_set_allocated_raw_default( ::pg_query::Node* raw_default); ::pg_query::Node* unsafe_arena_release_raw_default(); // .pg_query.Node cooked_default = 10 [json_name = "cooked_default"]; bool has_cooked_default() const; private: bool _internal_has_cooked_default() const; public: void clear_cooked_default(); const ::pg_query::Node& cooked_default() const; PROTOBUF_NODISCARD ::pg_query::Node* release_cooked_default(); ::pg_query::Node* mutable_cooked_default(); void set_allocated_cooked_default(::pg_query::Node* cooked_default); private: const ::pg_query::Node& _internal_cooked_default() const; ::pg_query::Node* _internal_mutable_cooked_default(); public: void unsafe_arena_set_allocated_cooked_default( ::pg_query::Node* cooked_default); ::pg_query::Node* unsafe_arena_release_cooked_default(); // .pg_query.RangeVar identity_sequence = 12 [json_name = "identitySequence"]; bool has_identity_sequence() const; private: bool _internal_has_identity_sequence() const; public: void clear_identity_sequence(); const ::pg_query::RangeVar& identity_sequence() const; PROTOBUF_NODISCARD ::pg_query::RangeVar* release_identity_sequence(); ::pg_query::RangeVar* mutable_identity_sequence(); void set_allocated_identity_sequence(::pg_query::RangeVar* identity_sequence); private: const ::pg_query::RangeVar& _internal_identity_sequence() const; ::pg_query::RangeVar* _internal_mutable_identity_sequence(); public: void unsafe_arena_set_allocated_identity_sequence( ::pg_query::RangeVar* identity_sequence); ::pg_query::RangeVar* unsafe_arena_release_identity_sequence(); // .pg_query.CollateClause coll_clause = 14 [json_name = "collClause"]; bool has_coll_clause() const; private: bool _internal_has_coll_clause() const; public: void clear_coll_clause(); const ::pg_query::CollateClause& coll_clause() const; PROTOBUF_NODISCARD ::pg_query::CollateClause* release_coll_clause(); ::pg_query::CollateClause* mutable_coll_clause(); void set_allocated_coll_clause(::pg_query::CollateClause* coll_clause); private: const ::pg_query::CollateClause& _internal_coll_clause() const; ::pg_query::CollateClause* _internal_mutable_coll_clause(); public: void unsafe_arena_set_allocated_coll_clause( ::pg_query::CollateClause* coll_clause); ::pg_query::CollateClause* unsafe_arena_release_coll_clause(); // int32 inhcount = 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 = 15 [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 = 18 [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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > constraints_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > fdwoptions_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr colname_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr compression_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr storage_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr identity_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr generated_; ::pg_query::TypeName* type_name_; ::pg_query::Node* raw_default_; ::pg_query::Node* cooked_default_; ::pg_query::RangeVar* identity_sequence_; ::pg_query::CollateClause* coll_clause_; int32_t inhcount_; bool is_local_; bool is_not_null_; bool is_from_type_; uint32_t coll_oid_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class IndexElem final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.IndexElem) */ { public: inline IndexElem() : IndexElem(nullptr) {} ~IndexElem() override; explicit PROTOBUF_CONSTEXPR IndexElem(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); IndexElem(const IndexElem& from); IndexElem(IndexElem&& from) noexcept : IndexElem() { *this = ::std::move(from); } inline IndexElem& operator=(const IndexElem& from) { CopyFrom(from); return *this; } inline IndexElem& operator=(IndexElem&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_IndexElem_default_instance_); } static constexpr int kIndexInFileMessages = 203; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(IndexElem* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- IndexElem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const IndexElem& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const IndexElem& from) { IndexElem::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(IndexElem* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.IndexElem"; } protected: explicit IndexElem(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_collation(); private: const ::pg_query::Node& _internal_collation(int index) const; ::pg_query::Node* _internal_add_collation(); public: const ::pg_query::Node& collation(int index) const; ::pg_query::Node* add_collation(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& collation() const; // repeated .pg_query.Node opclass = 5 [json_name = "opclass"]; int opclass_size() const; private: int _internal_opclass_size() const; public: void clear_opclass(); ::pg_query::Node* mutable_opclass(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_opclass(); private: const ::pg_query::Node& _internal_opclass(int index) const; ::pg_query::Node* _internal_add_opclass(); public: const ::pg_query::Node& opclass(int index) const; ::pg_query::Node* add_opclass(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& opclass() const; // repeated .pg_query.Node opclassopts = 6 [json_name = "opclassopts"]; int opclassopts_size() const; private: int _internal_opclassopts_size() const; public: void clear_opclassopts(); ::pg_query::Node* mutable_opclassopts(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_opclassopts(); private: const ::pg_query::Node& _internal_opclassopts(int index) const; ::pg_query::Node* _internal_add_opclassopts(); public: const ::pg_query::Node& opclassopts(int index) const; ::pg_query::Node* add_opclassopts(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& opclassopts() const; // string name = 1 [json_name = "name"]; void clear_name(); const std::string& name() const; template void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); 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 void set_indexcolname(ArgT0&& arg0, ArgT... args); std::string* mutable_indexcolname(); PROTOBUF_NODISCARD std::string* release_indexcolname(); void set_allocated_indexcolname(std::string* indexcolname); 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; private: bool _internal_has_expr() const; public: 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* expr); private: const ::pg_query::Node& _internal_expr() const; ::pg_query::Node* _internal_mutable_expr(); public: void unsafe_arena_set_allocated_expr( ::pg_query::Node* expr); ::pg_query::Node* unsafe_arena_release_expr(); // .pg_query.SortByDir ordering = 7 [json_name = "ordering"]; void clear_ordering(); ::pg_query::SortByDir ordering() const; void set_ordering(::pg_query::SortByDir value); private: ::pg_query::SortByDir _internal_ordering() const; void _internal_set_ordering(::pg_query::SortByDir value); public: // .pg_query.SortByNulls nulls_ordering = 8 [json_name = "nulls_ordering"]; void clear_nulls_ordering(); ::pg_query::SortByNulls nulls_ordering() const; void set_nulls_ordering(::pg_query::SortByNulls value); private: ::pg_query::SortByNulls _internal_nulls_ordering() const; void _internal_set_nulls_ordering(::pg_query::SortByNulls value); public: // @@protoc_insertion_point(class_scope:pg_query.IndexElem) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > collation_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > opclass_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > opclassopts_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr indexcolname_; ::pg_query::Node* expr_; int ordering_; int nulls_ordering_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class StatsElem final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.StatsElem) */ { public: inline StatsElem() : StatsElem(nullptr) {} ~StatsElem() override; explicit PROTOBUF_CONSTEXPR StatsElem(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); StatsElem(const StatsElem& 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 (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_StatsElem_default_instance_); } static constexpr int kIndexInFileMessages = 204; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(StatsElem* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- StatsElem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const StatsElem& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const StatsElem& from) { StatsElem::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(StatsElem* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.StatsElem"; } protected: explicit StatsElem(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); 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; private: bool _internal_has_expr() const; public: 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* expr); private: const ::pg_query::Node& _internal_expr() const; ::pg_query::Node* _internal_mutable_expr(); public: void unsafe_arena_set_allocated_expr( ::pg_query::Node* expr); ::pg_query::Node* unsafe_arena_release_expr(); // @@protoc_insertion_point(class_scope:pg_query.StatsElem) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; ::pg_query::Node* expr_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class Constraint final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.Constraint) */ { public: inline Constraint() : Constraint(nullptr) {} ~Constraint() override; explicit PROTOBUF_CONSTEXPR Constraint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); Constraint(const Constraint& from); Constraint(Constraint&& from) noexcept : Constraint() { *this = ::std::move(from); } inline Constraint& operator=(const Constraint& from) { CopyFrom(from); return *this; } inline Constraint& operator=(Constraint&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_Constraint_default_instance_); } static constexpr int kIndexInFileMessages = 205; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(Constraint* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- Constraint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Constraint& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const Constraint& from) { Constraint::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Constraint* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.Constraint"; } protected: explicit Constraint(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_keys(); private: const ::pg_query::Node& _internal_keys(int index) const; ::pg_query::Node* _internal_add_keys(); public: const ::pg_query::Node& keys(int index) const; ::pg_query::Node* add_keys(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& keys() const; // repeated .pg_query.Node including = 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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_including(); private: const ::pg_query::Node& _internal_including(int index) const; ::pg_query::Node* _internal_add_including(); public: const ::pg_query::Node& including(int index) const; ::pg_query::Node* add_including(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& including() const; // repeated .pg_query.Node exclusions = 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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_exclusions(); private: const ::pg_query::Node& _internal_exclusions(int index) const; ::pg_query::Node* _internal_add_exclusions(); public: const ::pg_query::Node& exclusions(int index) const; ::pg_query::Node* add_exclusions(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& exclusions() const; // repeated .pg_query.Node options = 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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_options(); private: const ::pg_query::Node& _internal_options(int index) const; ::pg_query::Node* _internal_add_options(); public: const ::pg_query::Node& options(int index) const; ::pg_query::Node* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& options() const; // repeated .pg_query.Node fk_attrs = 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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_fk_attrs(); private: const ::pg_query::Node& _internal_fk_attrs(int index) const; ::pg_query::Node* _internal_add_fk_attrs(); public: const ::pg_query::Node& fk_attrs(int index) const; ::pg_query::Node* add_fk_attrs(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& fk_attrs() const; // repeated .pg_query.Node pk_attrs = 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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_pk_attrs(); private: const ::pg_query::Node& _internal_pk_attrs(int index) const; ::pg_query::Node* _internal_add_pk_attrs(); public: const ::pg_query::Node& pk_attrs(int index) const; ::pg_query::Node* add_pk_attrs(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& pk_attrs() const; // repeated .pg_query.Node 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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_fk_del_set_cols(); private: const ::pg_query::Node& _internal_fk_del_set_cols(int index) const; ::pg_query::Node* _internal_add_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 ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_old_conpfeqop(); private: const ::pg_query::Node& _internal_old_conpfeqop(int index) const; ::pg_query::Node* _internal_add_old_conpfeqop(); public: const ::pg_query::Node& old_conpfeqop(int index) const; ::pg_query::Node* add_old_conpfeqop(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& old_conpfeqop() const; // string conname = 2 [json_name = "conname"]; void clear_conname(); const std::string& conname() const; template void set_conname(ArgT0&& arg0, ArgT... args); std::string* mutable_conname(); PROTOBUF_NODISCARD std::string* release_conname(); void set_allocated_conname(std::string* conname); 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 void set_cooked_expr(ArgT0&& arg0, ArgT... args); std::string* mutable_cooked_expr(); PROTOBUF_NODISCARD std::string* release_cooked_expr(); void set_allocated_cooked_expr(std::string* cooked_expr); 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 void set_generated_when(ArgT0&& arg0, ArgT... args); std::string* mutable_generated_when(); PROTOBUF_NODISCARD std::string* release_generated_when(); void set_allocated_generated_when(std::string* generated_when); 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 void set_indexname(ArgT0&& arg0, ArgT... args); std::string* mutable_indexname(); PROTOBUF_NODISCARD std::string* release_indexname(); void set_allocated_indexname(std::string* indexname); 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 void set_indexspace(ArgT0&& arg0, ArgT... args); std::string* mutable_indexspace(); PROTOBUF_NODISCARD std::string* release_indexspace(); void set_allocated_indexspace(std::string* indexspace); 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 void set_access_method(ArgT0&& arg0, ArgT... args); std::string* mutable_access_method(); PROTOBUF_NODISCARD std::string* release_access_method(); void set_allocated_access_method(std::string* access_method); 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 void set_fk_matchtype(ArgT0&& arg0, ArgT... args); std::string* mutable_fk_matchtype(); PROTOBUF_NODISCARD std::string* release_fk_matchtype(); void set_allocated_fk_matchtype(std::string* fk_matchtype); 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 void set_fk_upd_action(ArgT0&& arg0, ArgT... args); std::string* mutable_fk_upd_action(); PROTOBUF_NODISCARD std::string* release_fk_upd_action(); void set_allocated_fk_upd_action(std::string* fk_upd_action); private: const std::string& _internal_fk_upd_action() const; 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 void set_fk_del_action(ArgT0&& arg0, ArgT... args); std::string* mutable_fk_del_action(); PROTOBUF_NODISCARD std::string* release_fk_del_action(); void set_allocated_fk_del_action(std::string* fk_del_action); private: const std::string& _internal_fk_del_action() const; 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; private: bool _internal_has_raw_expr() const; public: 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* raw_expr); private: const ::pg_query::Node& _internal_raw_expr() const; ::pg_query::Node* _internal_mutable_raw_expr(); public: void unsafe_arena_set_allocated_raw_expr( ::pg_query::Node* raw_expr); ::pg_query::Node* unsafe_arena_release_raw_expr(); // .pg_query.Node where_clause = 19 [json_name = "where_clause"]; bool has_where_clause() const; private: bool _internal_has_where_clause() const; public: void clear_where_clause(); const ::pg_query::Node& where_clause() const; PROTOBUF_NODISCARD ::pg_query::Node* release_where_clause(); ::pg_query::Node* mutable_where_clause(); void set_allocated_where_clause(::pg_query::Node* where_clause); private: const ::pg_query::Node& _internal_where_clause() const; ::pg_query::Node* _internal_mutable_where_clause(); public: void unsafe_arena_set_allocated_where_clause( ::pg_query::Node* where_clause); ::pg_query::Node* unsafe_arena_release_where_clause(); // .pg_query.RangeVar pktable = 20 [json_name = "pktable"]; bool has_pktable() const; private: bool _internal_has_pktable() const; public: 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* pktable); private: const ::pg_query::RangeVar& _internal_pktable() const; ::pg_query::RangeVar* _internal_mutable_pktable(); public: void unsafe_arena_set_allocated_pktable( ::pg_query::RangeVar* pktable); ::pg_query::RangeVar* unsafe_arena_release_pktable(); // .pg_query.ConstrType contype = 1 [json_name = "contype"]; void clear_contype(); ::pg_query::ConstrType contype() const; void set_contype(::pg_query::ConstrType value); private: ::pg_query::ConstrType _internal_contype() const; void _internal_set_contype(::pg_query::ConstrType value); public: // int32 location = 5 [json_name = "location"]; void clear_location(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > keys_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > including_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > exclusions_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > options_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > fk_attrs_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > pk_attrs_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > fk_del_set_cols_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > old_conpfeqop_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conname_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cooked_expr_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr generated_when_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr indexname_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr indexspace_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr access_method_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fk_matchtype_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fk_upd_action_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fk_del_action_; ::pg_query::Node* raw_expr_; ::pg_query::Node* where_clause_; ::pg_query::RangeVar* pktable_; int contype_; 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_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class DefElem final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.DefElem) */ { public: inline DefElem() : DefElem(nullptr) {} ~DefElem() override; explicit PROTOBUF_CONSTEXPR DefElem(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); DefElem(const DefElem& from); DefElem(DefElem&& from) noexcept : DefElem() { *this = ::std::move(from); } inline DefElem& operator=(const DefElem& from) { CopyFrom(from); return *this; } inline DefElem& operator=(DefElem&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_DefElem_default_instance_); } static constexpr int kIndexInFileMessages = 206; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(DefElem* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- DefElem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DefElem& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const DefElem& from) { DefElem::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DefElem* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.DefElem"; } protected: explicit DefElem(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_defnamespace(ArgT0&& arg0, ArgT... args); std::string* mutable_defnamespace(); PROTOBUF_NODISCARD std::string* release_defnamespace(); void set_allocated_defnamespace(std::string* defnamespace); 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 void set_defname(ArgT0&& arg0, ArgT... args); std::string* mutable_defname(); PROTOBUF_NODISCARD std::string* release_defname(); void set_allocated_defname(std::string* defname); 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; private: bool _internal_has_arg() const; public: 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* arg); private: const ::pg_query::Node& _internal_arg() const; ::pg_query::Node* _internal_mutable_arg(); public: void unsafe_arena_set_allocated_arg( ::pg_query::Node* arg); ::pg_query::Node* unsafe_arena_release_arg(); // .pg_query.DefElemAction defaction = 4 [json_name = "defaction"]; void clear_defaction(); ::pg_query::DefElemAction defaction() const; void set_defaction(::pg_query::DefElemAction value); private: ::pg_query::DefElemAction _internal_defaction() const; void _internal_set_defaction(::pg_query::DefElemAction value); public: // int32 location = 5 [json_name = "location"]; void clear_location(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr defnamespace_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr defname_; ::pg_query::Node* arg_; int defaction_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class RangeTblEntry final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RangeTblEntry) */ { public: inline RangeTblEntry() : RangeTblEntry(nullptr) {} ~RangeTblEntry() override; explicit PROTOBUF_CONSTEXPR RangeTblEntry(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); RangeTblEntry(const RangeTblEntry& from); RangeTblEntry(RangeTblEntry&& from) noexcept : RangeTblEntry() { *this = ::std::move(from); } inline RangeTblEntry& operator=(const RangeTblEntry& from) { CopyFrom(from); return *this; } inline RangeTblEntry& operator=(RangeTblEntry&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_RangeTblEntry_default_instance_); } static constexpr int kIndexInFileMessages = 207; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(RangeTblEntry* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- RangeTblEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const RangeTblEntry& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const RangeTblEntry& from) { RangeTblEntry::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(RangeTblEntry* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.RangeTblEntry"; } protected: explicit RangeTblEntry(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kJoinaliasvarsFieldNumber = 10, kJoinleftcolsFieldNumber = 11, kJoinrightcolsFieldNumber = 12, kFunctionsFieldNumber = 14, kValuesListsFieldNumber = 17, kColtypesFieldNumber = 21, kColtypmodsFieldNumber = 22, kColcollationsFieldNumber = 23, kSelectedColsFieldNumber = 33, kInsertedColsFieldNumber = 34, kUpdatedColsFieldNumber = 35, kExtraUpdatedColsFieldNumber = 36, kSecurityQualsFieldNumber = 37, kRelkindFieldNumber = 3, kCtenameFieldNumber = 18, kEnrnameFieldNumber = 24, kTablesampleFieldNumber = 5, kSubqueryFieldNumber = 6, kJoinUsingAliasFieldNumber = 13, kTablefuncFieldNumber = 16, kAliasFieldNumber = 26, kErefFieldNumber = 27, kRtekindFieldNumber = 1, kRelidFieldNumber = 2, kRellockmodeFieldNumber = 4, kJointypeFieldNumber = 8, kJoinmergedcolsFieldNumber = 9, kSecurityBarrierFieldNumber = 7, kFuncordinalityFieldNumber = 15, kSelfReferenceFieldNumber = 20, kLateralFieldNumber = 28, kEnrtuplesFieldNumber = 25, kCtelevelsupFieldNumber = 19, kInhFieldNumber = 29, kInFromClFieldNumber = 30, kRequiredPermsFieldNumber = 31, kCheckAsUserFieldNumber = 32, }; // repeated .pg_query.Node joinaliasvars = 10 [json_name = "joinaliasvars"]; int joinaliasvars_size() const; private: int _internal_joinaliasvars_size() const; public: void clear_joinaliasvars(); ::pg_query::Node* mutable_joinaliasvars(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_joinaliasvars(); private: const ::pg_query::Node& _internal_joinaliasvars(int index) const; ::pg_query::Node* _internal_add_joinaliasvars(); public: const ::pg_query::Node& joinaliasvars(int index) const; ::pg_query::Node* add_joinaliasvars(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& joinaliasvars() const; // repeated .pg_query.Node joinleftcols = 11 [json_name = "joinleftcols"]; int joinleftcols_size() const; private: int _internal_joinleftcols_size() const; public: void clear_joinleftcols(); ::pg_query::Node* mutable_joinleftcols(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_joinleftcols(); private: const ::pg_query::Node& _internal_joinleftcols(int index) const; ::pg_query::Node* _internal_add_joinleftcols(); public: const ::pg_query::Node& joinleftcols(int index) const; ::pg_query::Node* add_joinleftcols(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& joinleftcols() const; // repeated .pg_query.Node joinrightcols = 12 [json_name = "joinrightcols"]; int joinrightcols_size() const; private: int _internal_joinrightcols_size() const; public: void clear_joinrightcols(); ::pg_query::Node* mutable_joinrightcols(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_joinrightcols(); private: const ::pg_query::Node& _internal_joinrightcols(int index) const; ::pg_query::Node* _internal_add_joinrightcols(); public: const ::pg_query::Node& joinrightcols(int index) const; ::pg_query::Node* add_joinrightcols(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& joinrightcols() const; // repeated .pg_query.Node functions = 14 [json_name = "functions"]; int functions_size() const; private: int _internal_functions_size() const; public: void clear_functions(); ::pg_query::Node* mutable_functions(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_functions(); private: const ::pg_query::Node& _internal_functions(int index) const; ::pg_query::Node* _internal_add_functions(); public: const ::pg_query::Node& functions(int index) const; ::pg_query::Node* add_functions(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& functions() const; // repeated .pg_query.Node values_lists = 17 [json_name = "values_lists"]; int values_lists_size() const; private: int _internal_values_lists_size() const; public: void clear_values_lists(); ::pg_query::Node* mutable_values_lists(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_values_lists(); private: const ::pg_query::Node& _internal_values_lists(int index) const; ::pg_query::Node* _internal_add_values_lists(); public: const ::pg_query::Node& values_lists(int index) const; ::pg_query::Node* add_values_lists(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& values_lists() const; // repeated .pg_query.Node coltypes = 21 [json_name = "coltypes"]; int coltypes_size() const; private: int _internal_coltypes_size() const; public: void clear_coltypes(); ::pg_query::Node* mutable_coltypes(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_coltypes(); private: const ::pg_query::Node& _internal_coltypes(int index) const; ::pg_query::Node* _internal_add_coltypes(); public: const ::pg_query::Node& coltypes(int index) const; ::pg_query::Node* add_coltypes(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& coltypes() const; // repeated .pg_query.Node coltypmods = 22 [json_name = "coltypmods"]; int coltypmods_size() const; private: int _internal_coltypmods_size() const; public: void clear_coltypmods(); ::pg_query::Node* mutable_coltypmods(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_coltypmods(); private: const ::pg_query::Node& _internal_coltypmods(int index) const; ::pg_query::Node* _internal_add_coltypmods(); public: const ::pg_query::Node& coltypmods(int index) const; ::pg_query::Node* add_coltypmods(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& coltypmods() const; // repeated .pg_query.Node colcollations = 23 [json_name = "colcollations"]; int colcollations_size() const; private: int _internal_colcollations_size() const; public: void clear_colcollations(); ::pg_query::Node* mutable_colcollations(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_colcollations(); private: const ::pg_query::Node& _internal_colcollations(int index) const; ::pg_query::Node* _internal_add_colcollations(); public: const ::pg_query::Node& colcollations(int index) const; ::pg_query::Node* add_colcollations(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& colcollations() const; // repeated uint64 selected_cols = 33 [json_name = "selectedCols"]; int selected_cols_size() const; private: int _internal_selected_cols_size() const; public: void clear_selected_cols(); private: uint64_t _internal_selected_cols(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >& _internal_selected_cols() const; void _internal_add_selected_cols(uint64_t value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >* _internal_mutable_selected_cols(); public: uint64_t selected_cols(int index) const; void set_selected_cols(int index, uint64_t value); void add_selected_cols(uint64_t value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >& selected_cols() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >* mutable_selected_cols(); // repeated uint64 inserted_cols = 34 [json_name = "insertedCols"]; int inserted_cols_size() const; private: int _internal_inserted_cols_size() const; public: void clear_inserted_cols(); private: uint64_t _internal_inserted_cols(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >& _internal_inserted_cols() const; void _internal_add_inserted_cols(uint64_t value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >* _internal_mutable_inserted_cols(); public: uint64_t inserted_cols(int index) const; void set_inserted_cols(int index, uint64_t value); void add_inserted_cols(uint64_t value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >& inserted_cols() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >* mutable_inserted_cols(); // repeated uint64 updated_cols = 35 [json_name = "updatedCols"]; int updated_cols_size() const; private: int _internal_updated_cols_size() const; public: void clear_updated_cols(); private: uint64_t _internal_updated_cols(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >& _internal_updated_cols() const; void _internal_add_updated_cols(uint64_t value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >* _internal_mutable_updated_cols(); public: uint64_t updated_cols(int index) const; void set_updated_cols(int index, uint64_t value); void add_updated_cols(uint64_t value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >& updated_cols() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >* mutable_updated_cols(); // repeated uint64 extra_updated_cols = 36 [json_name = "extraUpdatedCols"]; int extra_updated_cols_size() const; private: int _internal_extra_updated_cols_size() const; public: void clear_extra_updated_cols(); private: uint64_t _internal_extra_updated_cols(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >& _internal_extra_updated_cols() const; void _internal_add_extra_updated_cols(uint64_t value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >* _internal_mutable_extra_updated_cols(); public: uint64_t extra_updated_cols(int index) const; void set_extra_updated_cols(int index, uint64_t value); void add_extra_updated_cols(uint64_t value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >& extra_updated_cols() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >* mutable_extra_updated_cols(); // repeated .pg_query.Node security_quals = 37 [json_name = "securityQuals"]; int security_quals_size() const; private: int _internal_security_quals_size() const; public: void clear_security_quals(); ::pg_query::Node* mutable_security_quals(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_security_quals(); private: const ::pg_query::Node& _internal_security_quals(int index) const; ::pg_query::Node* _internal_add_security_quals(); public: const ::pg_query::Node& security_quals(int index) const; ::pg_query::Node* add_security_quals(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& security_quals() const; // string relkind = 3 [json_name = "relkind"]; void clear_relkind(); const std::string& relkind() const; template void set_relkind(ArgT0&& arg0, ArgT... args); std::string* mutable_relkind(); PROTOBUF_NODISCARD std::string* release_relkind(); void set_allocated_relkind(std::string* relkind); 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 = 18 [json_name = "ctename"]; void clear_ctename(); const std::string& ctename() const; template void set_ctename(ArgT0&& arg0, ArgT... args); std::string* mutable_ctename(); PROTOBUF_NODISCARD std::string* release_ctename(); void set_allocated_ctename(std::string* ctename); 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 = 24 [json_name = "enrname"]; void clear_enrname(); const std::string& enrname() const; template void set_enrname(ArgT0&& arg0, ArgT... args); std::string* mutable_enrname(); PROTOBUF_NODISCARD std::string* release_enrname(); void set_allocated_enrname(std::string* enrname); 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; private: bool _internal_has_tablesample() const; public: 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* tablesample); private: const ::pg_query::TableSampleClause& _internal_tablesample() const; ::pg_query::TableSampleClause* _internal_mutable_tablesample(); public: void unsafe_arena_set_allocated_tablesample( ::pg_query::TableSampleClause* tablesample); ::pg_query::TableSampleClause* unsafe_arena_release_tablesample(); // .pg_query.Query subquery = 6 [json_name = "subquery"]; bool has_subquery() const; private: bool _internal_has_subquery() const; public: void clear_subquery(); const ::pg_query::Query& subquery() const; PROTOBUF_NODISCARD ::pg_query::Query* release_subquery(); ::pg_query::Query* mutable_subquery(); void set_allocated_subquery(::pg_query::Query* subquery); private: const ::pg_query::Query& _internal_subquery() const; ::pg_query::Query* _internal_mutable_subquery(); public: void unsafe_arena_set_allocated_subquery( ::pg_query::Query* subquery); ::pg_query::Query* unsafe_arena_release_subquery(); // .pg_query.Alias join_using_alias = 13 [json_name = "join_using_alias"]; bool has_join_using_alias() const; private: bool _internal_has_join_using_alias() const; public: 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* join_using_alias); private: const ::pg_query::Alias& _internal_join_using_alias() const; ::pg_query::Alias* _internal_mutable_join_using_alias(); public: void unsafe_arena_set_allocated_join_using_alias( ::pg_query::Alias* join_using_alias); ::pg_query::Alias* unsafe_arena_release_join_using_alias(); // .pg_query.TableFunc tablefunc = 16 [json_name = "tablefunc"]; bool has_tablefunc() const; private: bool _internal_has_tablefunc() const; public: 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* tablefunc); private: const ::pg_query::TableFunc& _internal_tablefunc() const; ::pg_query::TableFunc* _internal_mutable_tablefunc(); public: void unsafe_arena_set_allocated_tablefunc( ::pg_query::TableFunc* tablefunc); ::pg_query::TableFunc* unsafe_arena_release_tablefunc(); // .pg_query.Alias alias = 26 [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* alias); private: const ::pg_query::Alias& _internal_alias() const; ::pg_query::Alias* _internal_mutable_alias(); public: void unsafe_arena_set_allocated_alias( ::pg_query::Alias* alias); ::pg_query::Alias* unsafe_arena_release_alias(); // .pg_query.Alias eref = 27 [json_name = "eref"]; bool has_eref() const; private: bool _internal_has_eref() const; public: 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* eref); private: const ::pg_query::Alias& _internal_eref() const; ::pg_query::Alias* _internal_mutable_eref(); public: void unsafe_arena_set_allocated_eref( ::pg_query::Alias* eref); ::pg_query::Alias* unsafe_arena_release_eref(); // .pg_query.RTEKind rtekind = 1 [json_name = "rtekind"]; void clear_rtekind(); ::pg_query::RTEKind rtekind() const; void set_rtekind(::pg_query::RTEKind value); private: ::pg_query::RTEKind _internal_rtekind() const; void _internal_set_rtekind(::pg_query::RTEKind value); public: // uint32 relid = 2 [json_name = "relid"]; void clear_relid(); 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: // .pg_query.JoinType jointype = 8 [json_name = "jointype"]; void clear_jointype(); ::pg_query::JoinType jointype() const; void set_jointype(::pg_query::JoinType value); private: ::pg_query::JoinType _internal_jointype() const; void _internal_set_jointype(::pg_query::JoinType value); public: // int32 joinmergedcols = 9 [json_name = "joinmergedcols"]; void clear_joinmergedcols(); 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 = 7 [json_name = "security_barrier"]; void clear_security_barrier(); bool security_barrier() const; void set_security_barrier(bool value); private: bool _internal_security_barrier() const; void _internal_set_security_barrier(bool value); public: // bool funcordinality = 15 [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 = 20 [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 = 28 [json_name = "lateral"]; void clear_lateral(); bool lateral() const; void set_lateral(bool value); private: bool _internal_lateral() const; void _internal_set_lateral(bool value); public: // double enrtuples = 25 [json_name = "enrtuples"]; void clear_enrtuples(); double enrtuples() const; void set_enrtuples(double value); private: double _internal_enrtuples() const; void _internal_set_enrtuples(double value); public: // uint32 ctelevelsup = 19 [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: // bool inh = 29 [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 = 30 [json_name = "inFromCl"]; void clear_in_from_cl(); bool in_from_cl() const; void set_in_from_cl(bool value); private: bool _internal_in_from_cl() const; void _internal_set_in_from_cl(bool value); public: // uint32 required_perms = 31 [json_name = "requiredPerms"]; void clear_required_perms(); uint32_t required_perms() const; void set_required_perms(uint32_t value); private: uint32_t _internal_required_perms() const; void _internal_set_required_perms(uint32_t value); public: // uint32 check_as_user = 32 [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.RangeTblEntry) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > joinaliasvars_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > joinleftcols_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > joinrightcols_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > functions_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > values_lists_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > coltypes_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > coltypmods_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > colcollations_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > selected_cols_; mutable std::atomic _selected_cols_cached_byte_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > inserted_cols_; mutable std::atomic _inserted_cols_cached_byte_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > updated_cols_; mutable std::atomic _updated_cols_cached_byte_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > extra_updated_cols_; mutable std::atomic _extra_updated_cols_cached_byte_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > security_quals_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr relkind_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ctename_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr enrname_; ::pg_query::TableSampleClause* tablesample_; ::pg_query::Query* subquery_; ::pg_query::Alias* join_using_alias_; ::pg_query::TableFunc* tablefunc_; ::pg_query::Alias* alias_; ::pg_query::Alias* eref_; int rtekind_; uint32_t relid_; int32_t rellockmode_; int jointype_; int32_t joinmergedcols_; bool security_barrier_; bool funcordinality_; bool self_reference_; bool lateral_; double enrtuples_; uint32_t ctelevelsup_; bool inh_; bool in_from_cl_; uint32_t required_perms_; uint32_t check_as_user_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class RangeTblFunction final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RangeTblFunction) */ { public: inline RangeTblFunction() : RangeTblFunction(nullptr) {} ~RangeTblFunction() override; explicit PROTOBUF_CONSTEXPR RangeTblFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); RangeTblFunction(const RangeTblFunction& from); RangeTblFunction(RangeTblFunction&& from) noexcept : RangeTblFunction() { *this = ::std::move(from); } inline RangeTblFunction& operator=(const RangeTblFunction& from) { CopyFrom(from); return *this; } inline RangeTblFunction& operator=(RangeTblFunction&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_RangeTblFunction_default_instance_); } static constexpr int kIndexInFileMessages = 208; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(RangeTblFunction* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- RangeTblFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const RangeTblFunction& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const RangeTblFunction& from) { RangeTblFunction::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(RangeTblFunction* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.RangeTblFunction"; } protected: explicit RangeTblFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_funccolnames(); private: const ::pg_query::Node& _internal_funccolnames(int index) const; ::pg_query::Node* _internal_add_funccolnames(); public: const ::pg_query::Node& funccolnames(int index) const; ::pg_query::Node* add_funccolnames(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& funccolnames() const; // repeated .pg_query.Node funccoltypes = 4 [json_name = "funccoltypes"]; int funccoltypes_size() const; private: int _internal_funccoltypes_size() const; public: void clear_funccoltypes(); ::pg_query::Node* mutable_funccoltypes(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_funccoltypes(); private: const ::pg_query::Node& _internal_funccoltypes(int index) const; ::pg_query::Node* _internal_add_funccoltypes(); public: const ::pg_query::Node& funccoltypes(int index) const; ::pg_query::Node* add_funccoltypes(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& funccoltypes() const; // repeated .pg_query.Node funccoltypmods = 5 [json_name = "funccoltypmods"]; int funccoltypmods_size() const; private: int _internal_funccoltypmods_size() const; public: void clear_funccoltypmods(); ::pg_query::Node* mutable_funccoltypmods(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_funccoltypmods(); private: const ::pg_query::Node& _internal_funccoltypmods(int index) const; ::pg_query::Node* _internal_add_funccoltypmods(); public: const ::pg_query::Node& funccoltypmods(int index) const; ::pg_query::Node* add_funccoltypmods(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& funccoltypmods() const; // repeated .pg_query.Node funccolcollations = 6 [json_name = "funccolcollations"]; int funccolcollations_size() const; private: int _internal_funccolcollations_size() const; public: void clear_funccolcollations(); ::pg_query::Node* mutable_funccolcollations(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_funccolcollations(); private: const ::pg_query::Node& _internal_funccolcollations(int index) const; ::pg_query::Node* _internal_add_funccolcollations(); public: const ::pg_query::Node& funccolcollations(int index) const; ::pg_query::Node* add_funccolcollations(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& funccolcollations() const; // repeated uint64 funcparams = 7 [json_name = "funcparams"]; int funcparams_size() const; private: int _internal_funcparams_size() const; public: void clear_funcparams(); private: uint64_t _internal_funcparams(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >& _internal_funcparams() const; void _internal_add_funcparams(uint64_t value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >* _internal_mutable_funcparams(); public: uint64_t funcparams(int index) const; void set_funcparams(int index, uint64_t value); void add_funcparams(uint64_t value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >& funcparams() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >* mutable_funcparams(); // .pg_query.Node funcexpr = 1 [json_name = "funcexpr"]; bool has_funcexpr() const; private: bool _internal_has_funcexpr() const; public: void clear_funcexpr(); const ::pg_query::Node& funcexpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_funcexpr(); ::pg_query::Node* mutable_funcexpr(); void set_allocated_funcexpr(::pg_query::Node* funcexpr); private: const ::pg_query::Node& _internal_funcexpr() const; ::pg_query::Node* _internal_mutable_funcexpr(); public: void unsafe_arena_set_allocated_funcexpr( ::pg_query::Node* funcexpr); ::pg_query::Node* unsafe_arena_release_funcexpr(); // int32 funccolcount = 2 [json_name = "funccolcount"]; void clear_funccolcount(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > funccolnames_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > funccoltypes_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > funccoltypmods_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > funccolcollations_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > funcparams_; mutable std::atomic _funcparams_cached_byte_size_; ::pg_query::Node* funcexpr_; int32_t funccolcount_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class TableSampleClause final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.TableSampleClause) */ { public: inline TableSampleClause() : TableSampleClause(nullptr) {} ~TableSampleClause() override; explicit PROTOBUF_CONSTEXPR TableSampleClause(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); TableSampleClause(const TableSampleClause& from); TableSampleClause(TableSampleClause&& from) noexcept : TableSampleClause() { *this = ::std::move(from); } inline TableSampleClause& operator=(const TableSampleClause& from) { CopyFrom(from); return *this; } inline TableSampleClause& operator=(TableSampleClause&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_TableSampleClause_default_instance_); } static constexpr int kIndexInFileMessages = 209; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(TableSampleClause* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- TableSampleClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const TableSampleClause& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const TableSampleClause& from) { TableSampleClause::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(TableSampleClause* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.TableSampleClause"; } protected: explicit TableSampleClause(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_args(); private: const ::pg_query::Node& _internal_args(int index) const; ::pg_query::Node* _internal_add_args(); public: const ::pg_query::Node& args(int index) const; ::pg_query::Node* add_args(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& args() const; // .pg_query.Node repeatable = 3 [json_name = "repeatable"]; bool has_repeatable() const; private: bool _internal_has_repeatable() const; public: void clear_repeatable(); const ::pg_query::Node& repeatable() const; PROTOBUF_NODISCARD ::pg_query::Node* release_repeatable(); ::pg_query::Node* mutable_repeatable(); void set_allocated_repeatable(::pg_query::Node* repeatable); private: const ::pg_query::Node& _internal_repeatable() const; ::pg_query::Node* _internal_mutable_repeatable(); public: void unsafe_arena_set_allocated_repeatable( ::pg_query::Node* repeatable); ::pg_query::Node* unsafe_arena_release_repeatable(); // uint32 tsmhandler = 1 [json_name = "tsmhandler"]; void clear_tsmhandler(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > args_; ::pg_query::Node* repeatable_; uint32_t tsmhandler_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class WithCheckOption final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.WithCheckOption) */ { public: inline WithCheckOption() : WithCheckOption(nullptr) {} ~WithCheckOption() override; explicit PROTOBUF_CONSTEXPR WithCheckOption(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); WithCheckOption(const WithCheckOption& from); WithCheckOption(WithCheckOption&& from) noexcept : WithCheckOption() { *this = ::std::move(from); } inline WithCheckOption& operator=(const WithCheckOption& from) { CopyFrom(from); return *this; } inline WithCheckOption& operator=(WithCheckOption&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_WithCheckOption_default_instance_); } static constexpr int kIndexInFileMessages = 210; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(WithCheckOption* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- WithCheckOption* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const WithCheckOption& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const WithCheckOption& from) { WithCheckOption::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(WithCheckOption* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.WithCheckOption"; } protected: explicit WithCheckOption(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_relname(ArgT0&& arg0, ArgT... args); std::string* mutable_relname(); PROTOBUF_NODISCARD std::string* release_relname(); void set_allocated_relname(std::string* relname); 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 void set_polname(ArgT0&& arg0, ArgT... args); std::string* mutable_polname(); PROTOBUF_NODISCARD std::string* release_polname(); void set_allocated_polname(std::string* polname); 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; private: bool _internal_has_qual() const; public: 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* qual); private: const ::pg_query::Node& _internal_qual() const; ::pg_query::Node* _internal_mutable_qual(); public: void unsafe_arena_set_allocated_qual( ::pg_query::Node* qual); ::pg_query::Node* unsafe_arena_release_qual(); // .pg_query.WCOKind kind = 1 [json_name = "kind"]; void clear_kind(); ::pg_query::WCOKind kind() const; void set_kind(::pg_query::WCOKind value); private: ::pg_query::WCOKind _internal_kind() const; void _internal_set_kind(::pg_query::WCOKind value); public: // bool cascaded = 5 [json_name = "cascaded"]; void clear_cascaded(); bool cascaded() const; void set_cascaded(bool value); private: bool _internal_cascaded() const; void _internal_set_cascaded(bool value); public: // @@protoc_insertion_point(class_scope:pg_query.WithCheckOption) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr relname_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr polname_; ::pg_query::Node* qual_; int kind_; bool cascaded_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class SortGroupClause final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.SortGroupClause) */ { public: inline SortGroupClause() : SortGroupClause(nullptr) {} ~SortGroupClause() override; explicit PROTOBUF_CONSTEXPR SortGroupClause(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); SortGroupClause(const SortGroupClause& from); SortGroupClause(SortGroupClause&& from) noexcept : SortGroupClause() { *this = ::std::move(from); } inline SortGroupClause& operator=(const SortGroupClause& from) { CopyFrom(from); return *this; } inline SortGroupClause& operator=(SortGroupClause&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_SortGroupClause_default_instance_); } static constexpr int kIndexInFileMessages = 211; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SortGroupClause* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- SortGroupClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const SortGroupClause& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const SortGroupClause& from) { SortGroupClause::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(SortGroupClause* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.SortGroupClause"; } protected: explicit SortGroupClause(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { uint32_t tle_sort_group_ref_; uint32_t eqop_; uint32_t sortop_; bool nulls_first_; bool hashable_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class GroupingSet final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.GroupingSet) */ { public: inline GroupingSet() : GroupingSet(nullptr) {} ~GroupingSet() override; explicit PROTOBUF_CONSTEXPR GroupingSet(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); GroupingSet(const GroupingSet& from); GroupingSet(GroupingSet&& from) noexcept : GroupingSet() { *this = ::std::move(from); } inline GroupingSet& operator=(const GroupingSet& from) { CopyFrom(from); return *this; } inline GroupingSet& operator=(GroupingSet&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_GroupingSet_default_instance_); } static constexpr int kIndexInFileMessages = 212; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(GroupingSet* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- GroupingSet* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const GroupingSet& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const GroupingSet& from) { GroupingSet::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(GroupingSet* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.GroupingSet"; } protected: explicit GroupingSet(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_content(); private: const ::pg_query::Node& _internal_content(int index) const; ::pg_query::Node* _internal_add_content(); public: const ::pg_query::Node& content(int index) const; ::pg_query::Node* add_content(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& content() const; // .pg_query.GroupingSetKind kind = 1 [json_name = "kind"]; void clear_kind(); ::pg_query::GroupingSetKind kind() const; void set_kind(::pg_query::GroupingSetKind value); private: ::pg_query::GroupingSetKind _internal_kind() const; void _internal_set_kind(::pg_query::GroupingSetKind value); public: // int32 location = 3 [json_name = "location"]; void clear_location(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > content_; int kind_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class WindowClause final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.WindowClause) */ { public: inline WindowClause() : WindowClause(nullptr) {} ~WindowClause() override; explicit PROTOBUF_CONSTEXPR WindowClause(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); WindowClause(const WindowClause& from); WindowClause(WindowClause&& from) noexcept : WindowClause() { *this = ::std::move(from); } inline WindowClause& operator=(const WindowClause& from) { CopyFrom(from); return *this; } inline WindowClause& operator=(WindowClause&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_WindowClause_default_instance_); } static constexpr int kIndexInFileMessages = 213; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(WindowClause* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- WindowClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const WindowClause& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const WindowClause& from) { WindowClause::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(WindowClause* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.WindowClause"; } protected: explicit WindowClause(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_partition_clause(); private: const ::pg_query::Node& _internal_partition_clause(int index) const; ::pg_query::Node* _internal_add_partition_clause(); public: const ::pg_query::Node& partition_clause(int index) const; ::pg_query::Node* add_partition_clause(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& partition_clause() const; // repeated .pg_query.Node order_clause = 4 [json_name = "orderClause"]; int order_clause_size() const; private: int _internal_order_clause_size() const; public: void clear_order_clause(); ::pg_query::Node* mutable_order_clause(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_order_clause(); private: const ::pg_query::Node& _internal_order_clause(int index) const; ::pg_query::Node* _internal_add_order_clause(); public: const ::pg_query::Node& order_clause(int index) const; ::pg_query::Node* add_order_clause(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& order_clause() const; // 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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_run_condition(); private: const ::pg_query::Node& _internal_run_condition(int index) const; ::pg_query::Node* _internal_add_run_condition(); public: const ::pg_query::Node& run_condition(int index) const; ::pg_query::Node* add_run_condition(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& run_condition() const; // string name = 1 [json_name = "name"]; void clear_name(); const std::string& name() const; template void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); 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 void set_refname(ArgT0&& arg0, ArgT... args); std::string* mutable_refname(); PROTOBUF_NODISCARD std::string* release_refname(); void set_allocated_refname(std::string* refname); 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; private: bool _internal_has_start_offset() const; public: 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* start_offset); private: const ::pg_query::Node& _internal_start_offset() const; ::pg_query::Node* _internal_mutable_start_offset(); public: void unsafe_arena_set_allocated_start_offset( ::pg_query::Node* start_offset); ::pg_query::Node* unsafe_arena_release_start_offset(); // .pg_query.Node end_offset = 7 [json_name = "endOffset"]; bool has_end_offset() const; private: bool _internal_has_end_offset() const; public: void clear_end_offset(); const ::pg_query::Node& end_offset() const; PROTOBUF_NODISCARD ::pg_query::Node* release_end_offset(); ::pg_query::Node* mutable_end_offset(); void set_allocated_end_offset(::pg_query::Node* end_offset); private: const ::pg_query::Node& _internal_end_offset() const; ::pg_query::Node* _internal_mutable_end_offset(); public: void unsafe_arena_set_allocated_end_offset( ::pg_query::Node* end_offset); ::pg_query::Node* unsafe_arena_release_end_offset(); // int32 frame_options = 5 [json_name = "frameOptions"]; void clear_frame_options(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > partition_clause_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > order_clause_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > run_condition_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; ::PROTOBUF_NAMESPACE_ID::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_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class ObjectWithArgs final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ObjectWithArgs) */ { public: inline ObjectWithArgs() : ObjectWithArgs(nullptr) {} ~ObjectWithArgs() override; explicit PROTOBUF_CONSTEXPR ObjectWithArgs(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ObjectWithArgs(const ObjectWithArgs& from); ObjectWithArgs(ObjectWithArgs&& from) noexcept : ObjectWithArgs() { *this = ::std::move(from); } inline ObjectWithArgs& operator=(const ObjectWithArgs& from) { CopyFrom(from); return *this; } inline ObjectWithArgs& operator=(ObjectWithArgs&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_ObjectWithArgs_default_instance_); } static constexpr int kIndexInFileMessages = 214; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ObjectWithArgs* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ObjectWithArgs* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ObjectWithArgs& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ObjectWithArgs& from) { ObjectWithArgs::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ObjectWithArgs* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.ObjectWithArgs"; } protected: explicit ObjectWithArgs(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_objname(); private: const ::pg_query::Node& _internal_objname(int index) const; ::pg_query::Node* _internal_add_objname(); public: const ::pg_query::Node& objname(int index) const; ::pg_query::Node* add_objname(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& objname() const; // repeated .pg_query.Node objargs = 2 [json_name = "objargs"]; int objargs_size() const; private: int _internal_objargs_size() const; public: void clear_objargs(); ::pg_query::Node* mutable_objargs(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_objargs(); private: const ::pg_query::Node& _internal_objargs(int index) const; ::pg_query::Node* _internal_add_objargs(); public: const ::pg_query::Node& objargs(int index) const; ::pg_query::Node* add_objargs(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& objargs() const; // 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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_objfuncargs(); private: const ::pg_query::Node& _internal_objfuncargs(int index) const; ::pg_query::Node* _internal_add_objfuncargs(); public: const ::pg_query::Node& objfuncargs(int index) const; ::pg_query::Node* add_objfuncargs(); const ::PROTOBUF_NAMESPACE_ID::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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > objname_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > objargs_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > objfuncargs_; bool args_unspecified_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class AccessPriv final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.AccessPriv) */ { public: inline AccessPriv() : AccessPriv(nullptr) {} ~AccessPriv() override; explicit PROTOBUF_CONSTEXPR AccessPriv(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); AccessPriv(const AccessPriv& from); AccessPriv(AccessPriv&& from) noexcept : AccessPriv() { *this = ::std::move(from); } inline AccessPriv& operator=(const AccessPriv& from) { CopyFrom(from); return *this; } inline AccessPriv& operator=(AccessPriv&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_AccessPriv_default_instance_); } static constexpr int kIndexInFileMessages = 215; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AccessPriv* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- AccessPriv* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AccessPriv& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const AccessPriv& from) { AccessPriv::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AccessPriv* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.AccessPriv"; } protected: explicit AccessPriv(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_cols(); private: const ::pg_query::Node& _internal_cols(int index) const; ::pg_query::Node* _internal_add_cols(); public: const ::pg_query::Node& cols(int index) const; ::pg_query::Node* add_cols(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& cols() const; // string priv_name = 1 [json_name = "priv_name"]; void clear_priv_name(); const std::string& priv_name() const; template void set_priv_name(ArgT0&& arg0, ArgT... args); std::string* mutable_priv_name(); PROTOBUF_NODISCARD std::string* release_priv_name(); void set_allocated_priv_name(std::string* priv_name); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > cols_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr priv_name_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CreateOpClassItem final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CreateOpClassItem) */ { public: inline CreateOpClassItem() : CreateOpClassItem(nullptr) {} ~CreateOpClassItem() override; explicit PROTOBUF_CONSTEXPR CreateOpClassItem(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CreateOpClassItem(const CreateOpClassItem& from); CreateOpClassItem(CreateOpClassItem&& from) noexcept : CreateOpClassItem() { *this = ::std::move(from); } inline CreateOpClassItem& operator=(const CreateOpClassItem& from) { CopyFrom(from); return *this; } inline CreateOpClassItem& operator=(CreateOpClassItem&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CreateOpClassItem_default_instance_); } static constexpr int kIndexInFileMessages = 216; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CreateOpClassItem* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CreateOpClassItem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CreateOpClassItem& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CreateOpClassItem& from) { CreateOpClassItem::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CreateOpClassItem* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CreateOpClassItem"; } protected: explicit CreateOpClassItem(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_order_family(); private: const ::pg_query::Node& _internal_order_family(int index) const; ::pg_query::Node* _internal_add_order_family(); public: const ::pg_query::Node& order_family(int index) const; ::pg_query::Node* add_order_family(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& order_family() const; // repeated .pg_query.Node class_args = 5 [json_name = "class_args"]; int class_args_size() const; private: int _internal_class_args_size() const; public: void clear_class_args(); ::pg_query::Node* mutable_class_args(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_class_args(); private: const ::pg_query::Node& _internal_class_args(int index) const; ::pg_query::Node* _internal_add_class_args(); public: const ::pg_query::Node& class_args(int index) const; ::pg_query::Node* add_class_args(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& class_args() const; // .pg_query.ObjectWithArgs name = 2 [json_name = "name"]; bool has_name() const; private: bool _internal_has_name() const; public: void clear_name(); const ::pg_query::ObjectWithArgs& name() const; PROTOBUF_NODISCARD ::pg_query::ObjectWithArgs* release_name(); ::pg_query::ObjectWithArgs* mutable_name(); void set_allocated_name(::pg_query::ObjectWithArgs* name); private: const ::pg_query::ObjectWithArgs& _internal_name() const; ::pg_query::ObjectWithArgs* _internal_mutable_name(); public: void unsafe_arena_set_allocated_name( ::pg_query::ObjectWithArgs* name); ::pg_query::ObjectWithArgs* unsafe_arena_release_name(); // .pg_query.TypeName storedtype = 6 [json_name = "storedtype"]; bool has_storedtype() const; private: bool _internal_has_storedtype() const; public: void clear_storedtype(); const ::pg_query::TypeName& storedtype() const; PROTOBUF_NODISCARD ::pg_query::TypeName* release_storedtype(); ::pg_query::TypeName* mutable_storedtype(); void set_allocated_storedtype(::pg_query::TypeName* storedtype); private: const ::pg_query::TypeName& _internal_storedtype() const; ::pg_query::TypeName* _internal_mutable_storedtype(); public: void unsafe_arena_set_allocated_storedtype( ::pg_query::TypeName* storedtype); ::pg_query::TypeName* unsafe_arena_release_storedtype(); // int32 itemtype = 1 [json_name = "itemtype"]; void clear_itemtype(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > order_family_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > class_args_; ::pg_query::ObjectWithArgs* name_; ::pg_query::TypeName* storedtype_; int32_t itemtype_; int32_t number_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class TableLikeClause final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.TableLikeClause) */ { public: inline TableLikeClause() : TableLikeClause(nullptr) {} ~TableLikeClause() override; explicit PROTOBUF_CONSTEXPR TableLikeClause(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); TableLikeClause(const TableLikeClause& from); TableLikeClause(TableLikeClause&& from) noexcept : TableLikeClause() { *this = ::std::move(from); } inline TableLikeClause& operator=(const TableLikeClause& from) { CopyFrom(from); return *this; } inline TableLikeClause& operator=(TableLikeClause&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_TableLikeClause_default_instance_); } static constexpr int kIndexInFileMessages = 217; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(TableLikeClause* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- TableLikeClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const TableLikeClause& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const TableLikeClause& from) { TableLikeClause::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(TableLikeClause* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.TableLikeClause"; } protected: explicit TableLikeClause(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_relation() const; public: 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* relation); private: const ::pg_query::RangeVar& _internal_relation() const; ::pg_query::RangeVar* _internal_mutable_relation(); public: void unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation); ::pg_query::RangeVar* unsafe_arena_release_relation(); // uint32 options = 2 [json_name = "options"]; void clear_options(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::RangeVar* relation_; uint32_t options_; uint32_t relation_oid_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class FunctionParameter final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.FunctionParameter) */ { public: inline FunctionParameter() : FunctionParameter(nullptr) {} ~FunctionParameter() override; explicit PROTOBUF_CONSTEXPR FunctionParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); FunctionParameter(const FunctionParameter& from); FunctionParameter(FunctionParameter&& from) noexcept : FunctionParameter() { *this = ::std::move(from); } inline FunctionParameter& operator=(const FunctionParameter& from) { CopyFrom(from); return *this; } inline FunctionParameter& operator=(FunctionParameter&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_FunctionParameter_default_instance_); } static constexpr int kIndexInFileMessages = 218; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(FunctionParameter* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- FunctionParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const FunctionParameter& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const FunctionParameter& from) { FunctionParameter::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(FunctionParameter* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.FunctionParameter"; } protected: explicit FunctionParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); 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; private: bool _internal_has_arg_type() const; public: 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* arg_type); private: const ::pg_query::TypeName& _internal_arg_type() const; ::pg_query::TypeName* _internal_mutable_arg_type(); public: void unsafe_arena_set_allocated_arg_type( ::pg_query::TypeName* arg_type); ::pg_query::TypeName* unsafe_arena_release_arg_type(); // .pg_query.Node defexpr = 4 [json_name = "defexpr"]; bool has_defexpr() const; private: bool _internal_has_defexpr() const; public: void clear_defexpr(); const ::pg_query::Node& defexpr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_defexpr(); ::pg_query::Node* mutable_defexpr(); void set_allocated_defexpr(::pg_query::Node* defexpr); private: const ::pg_query::Node& _internal_defexpr() const; ::pg_query::Node* _internal_mutable_defexpr(); public: void unsafe_arena_set_allocated_defexpr( ::pg_query::Node* defexpr); ::pg_query::Node* unsafe_arena_release_defexpr(); // .pg_query.FunctionParameterMode mode = 3 [json_name = "mode"]; void clear_mode(); ::pg_query::FunctionParameterMode mode() const; void set_mode(::pg_query::FunctionParameterMode value); private: ::pg_query::FunctionParameterMode _internal_mode() const; void _internal_set_mode(::pg_query::FunctionParameterMode value); public: // @@protoc_insertion_point(class_scope:pg_query.FunctionParameter) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; ::pg_query::TypeName* arg_type_; ::pg_query::Node* defexpr_; int mode_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class LockingClause final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.LockingClause) */ { public: inline LockingClause() : LockingClause(nullptr) {} ~LockingClause() override; explicit PROTOBUF_CONSTEXPR LockingClause(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); LockingClause(const LockingClause& from); LockingClause(LockingClause&& from) noexcept : LockingClause() { *this = ::std::move(from); } inline LockingClause& operator=(const LockingClause& from) { CopyFrom(from); return *this; } inline LockingClause& operator=(LockingClause&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_LockingClause_default_instance_); } static constexpr int kIndexInFileMessages = 219; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(LockingClause* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- LockingClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const LockingClause& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const LockingClause& from) { LockingClause::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(LockingClause* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.LockingClause"; } protected: explicit LockingClause(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_locked_rels(); private: const ::pg_query::Node& _internal_locked_rels(int index) const; ::pg_query::Node* _internal_add_locked_rels(); public: const ::pg_query::Node& locked_rels(int index) const; ::pg_query::Node* add_locked_rels(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& locked_rels() const; // .pg_query.LockClauseStrength strength = 2 [json_name = "strength"]; void clear_strength(); ::pg_query::LockClauseStrength strength() const; void set_strength(::pg_query::LockClauseStrength value); private: ::pg_query::LockClauseStrength _internal_strength() const; void _internal_set_strength(::pg_query::LockClauseStrength value); public: // .pg_query.LockWaitPolicy wait_policy = 3 [json_name = "waitPolicy"]; void clear_wait_policy(); ::pg_query::LockWaitPolicy wait_policy() const; void set_wait_policy(::pg_query::LockWaitPolicy value); private: ::pg_query::LockWaitPolicy _internal_wait_policy() const; void _internal_set_wait_policy(::pg_query::LockWaitPolicy value); public: // @@protoc_insertion_point(class_scope:pg_query.LockingClause) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > locked_rels_; int strength_; int wait_policy_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class RowMarkClause final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RowMarkClause) */ { public: inline RowMarkClause() : RowMarkClause(nullptr) {} ~RowMarkClause() override; explicit PROTOBUF_CONSTEXPR RowMarkClause(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); RowMarkClause(const RowMarkClause& from); RowMarkClause(RowMarkClause&& from) noexcept : RowMarkClause() { *this = ::std::move(from); } inline RowMarkClause& operator=(const RowMarkClause& from) { CopyFrom(from); return *this; } inline RowMarkClause& operator=(RowMarkClause&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_RowMarkClause_default_instance_); } static constexpr int kIndexInFileMessages = 220; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(RowMarkClause* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- RowMarkClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const RowMarkClause& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const RowMarkClause& from) { RowMarkClause::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(RowMarkClause* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.RowMarkClause"; } protected: explicit RowMarkClause(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { uint32_t rti_; int strength_; int wait_policy_; bool pushed_down_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class XmlSerialize final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.XmlSerialize) */ { public: inline XmlSerialize() : XmlSerialize(nullptr) {} ~XmlSerialize() override; explicit PROTOBUF_CONSTEXPR XmlSerialize(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); XmlSerialize(const XmlSerialize& from); XmlSerialize(XmlSerialize&& from) noexcept : XmlSerialize() { *this = ::std::move(from); } inline XmlSerialize& operator=(const XmlSerialize& from) { CopyFrom(from); return *this; } inline XmlSerialize& operator=(XmlSerialize&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_XmlSerialize_default_instance_); } static constexpr int kIndexInFileMessages = 221; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(XmlSerialize* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- XmlSerialize* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const XmlSerialize& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const XmlSerialize& from) { XmlSerialize::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(XmlSerialize* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.XmlSerialize"; } protected: explicit XmlSerialize(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kExprFieldNumber = 2, kTypeNameFieldNumber = 3, kXmloptionFieldNumber = 1, kLocationFieldNumber = 4, }; // .pg_query.Node expr = 2 [json_name = "expr"]; bool has_expr() const; private: bool _internal_has_expr() const; public: void clear_expr(); const ::pg_query::Node& expr() const; PROTOBUF_NODISCARD ::pg_query::Node* release_expr(); ::pg_query::Node* mutable_expr(); void set_allocated_expr(::pg_query::Node* expr); private: const ::pg_query::Node& _internal_expr() const; ::pg_query::Node* _internal_mutable_expr(); public: void unsafe_arena_set_allocated_expr( ::pg_query::Node* expr); ::pg_query::Node* unsafe_arena_release_expr(); // .pg_query.TypeName type_name = 3 [json_name = "typeName"]; bool has_type_name() const; private: bool _internal_has_type_name() const; public: void clear_type_name(); const ::pg_query::TypeName& type_name() const; PROTOBUF_NODISCARD ::pg_query::TypeName* release_type_name(); ::pg_query::TypeName* mutable_type_name(); void set_allocated_type_name(::pg_query::TypeName* type_name); private: const ::pg_query::TypeName& _internal_type_name() const; ::pg_query::TypeName* _internal_mutable_type_name(); public: void unsafe_arena_set_allocated_type_name( ::pg_query::TypeName* type_name); ::pg_query::TypeName* unsafe_arena_release_type_name(); // .pg_query.XmlOptionType xmloption = 1 [json_name = "xmloption"]; void clear_xmloption(); ::pg_query::XmlOptionType xmloption() const; void set_xmloption(::pg_query::XmlOptionType value); private: ::pg_query::XmlOptionType _internal_xmloption() const; void _internal_set_xmloption(::pg_query::XmlOptionType value); public: // int32 location = 4 [json_name = "location"]; void clear_location(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::Node* expr_; ::pg_query::TypeName* type_name_; int xmloption_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class WithClause final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.WithClause) */ { public: inline WithClause() : WithClause(nullptr) {} ~WithClause() override; explicit PROTOBUF_CONSTEXPR WithClause(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); WithClause(const WithClause& from); WithClause(WithClause&& from) noexcept : WithClause() { *this = ::std::move(from); } inline WithClause& operator=(const WithClause& from) { CopyFrom(from); return *this; } inline WithClause& operator=(WithClause&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_WithClause_default_instance_); } static constexpr int kIndexInFileMessages = 222; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(WithClause* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- WithClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const WithClause& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const WithClause& from) { WithClause::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(WithClause* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.WithClause"; } protected: explicit WithClause(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_ctes(); private: const ::pg_query::Node& _internal_ctes(int index) const; ::pg_query::Node* _internal_add_ctes(); public: const ::pg_query::Node& ctes(int index) const; ::pg_query::Node* add_ctes(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& ctes() const; // bool recursive = 2 [json_name = "recursive"]; void clear_recursive(); bool recursive() const; void set_recursive(bool value); private: bool _internal_recursive() const; void _internal_set_recursive(bool value); public: // int32 location = 3 [json_name = "location"]; void clear_location(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > ctes_; bool recursive_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class InferClause final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.InferClause) */ { public: inline InferClause() : InferClause(nullptr) {} ~InferClause() override; explicit PROTOBUF_CONSTEXPR InferClause(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); InferClause(const InferClause& from); InferClause(InferClause&& from) noexcept : InferClause() { *this = ::std::move(from); } inline InferClause& operator=(const InferClause& from) { CopyFrom(from); return *this; } inline InferClause& operator=(InferClause&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_InferClause_default_instance_); } static constexpr int kIndexInFileMessages = 223; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(InferClause* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- InferClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const InferClause& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const InferClause& from) { InferClause::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(InferClause* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.InferClause"; } protected: explicit InferClause(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_index_elems(); private: const ::pg_query::Node& _internal_index_elems(int index) const; ::pg_query::Node* _internal_add_index_elems(); public: const ::pg_query::Node& index_elems(int index) const; ::pg_query::Node* add_index_elems(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& index_elems() const; // string conname = 3 [json_name = "conname"]; void clear_conname(); const std::string& conname() const; template void set_conname(ArgT0&& arg0, ArgT... args); std::string* mutable_conname(); PROTOBUF_NODISCARD std::string* release_conname(); void set_allocated_conname(std::string* conname); 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; private: bool _internal_has_where_clause() const; public: 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* where_clause); private: const ::pg_query::Node& _internal_where_clause() const; ::pg_query::Node* _internal_mutable_where_clause(); public: void unsafe_arena_set_allocated_where_clause( ::pg_query::Node* where_clause); ::pg_query::Node* unsafe_arena_release_where_clause(); // int32 location = 4 [json_name = "location"]; void clear_location(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > index_elems_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conname_; ::pg_query::Node* where_clause_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class OnConflictClause final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.OnConflictClause) */ { public: inline OnConflictClause() : OnConflictClause(nullptr) {} ~OnConflictClause() override; explicit PROTOBUF_CONSTEXPR OnConflictClause(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); OnConflictClause(const OnConflictClause& from); OnConflictClause(OnConflictClause&& from) noexcept : OnConflictClause() { *this = ::std::move(from); } inline OnConflictClause& operator=(const OnConflictClause& from) { CopyFrom(from); return *this; } inline OnConflictClause& operator=(OnConflictClause&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_OnConflictClause_default_instance_); } static constexpr int kIndexInFileMessages = 224; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(OnConflictClause* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- OnConflictClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const OnConflictClause& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const OnConflictClause& from) { OnConflictClause::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(OnConflictClause* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.OnConflictClause"; } protected: explicit OnConflictClause(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_target_list(); private: const ::pg_query::Node& _internal_target_list(int index) const; ::pg_query::Node* _internal_add_target_list(); public: const ::pg_query::Node& target_list(int index) const; ::pg_query::Node* add_target_list(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& target_list() const; // .pg_query.InferClause infer = 2 [json_name = "infer"]; bool has_infer() const; private: bool _internal_has_infer() const; public: void clear_infer(); const ::pg_query::InferClause& infer() const; PROTOBUF_NODISCARD ::pg_query::InferClause* release_infer(); ::pg_query::InferClause* mutable_infer(); void set_allocated_infer(::pg_query::InferClause* infer); private: const ::pg_query::InferClause& _internal_infer() const; ::pg_query::InferClause* _internal_mutable_infer(); public: void unsafe_arena_set_allocated_infer( ::pg_query::InferClause* infer); ::pg_query::InferClause* unsafe_arena_release_infer(); // .pg_query.Node where_clause = 4 [json_name = "whereClause"]; bool has_where_clause() const; private: bool _internal_has_where_clause() const; public: void clear_where_clause(); const ::pg_query::Node& where_clause() const; PROTOBUF_NODISCARD ::pg_query::Node* release_where_clause(); ::pg_query::Node* mutable_where_clause(); void set_allocated_where_clause(::pg_query::Node* where_clause); private: const ::pg_query::Node& _internal_where_clause() const; ::pg_query::Node* _internal_mutable_where_clause(); public: void unsafe_arena_set_allocated_where_clause( ::pg_query::Node* where_clause); ::pg_query::Node* unsafe_arena_release_where_clause(); // .pg_query.OnConflictAction action = 1 [json_name = "action"]; void clear_action(); ::pg_query::OnConflictAction action() const; void set_action(::pg_query::OnConflictAction value); private: ::pg_query::OnConflictAction _internal_action() const; void _internal_set_action(::pg_query::OnConflictAction value); public: // int32 location = 5 [json_name = "location"]; void clear_location(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > target_list_; ::pg_query::InferClause* infer_; ::pg_query::Node* where_clause_; int action_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CTESearchClause final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CTESearchClause) */ { public: inline CTESearchClause() : CTESearchClause(nullptr) {} ~CTESearchClause() override; explicit PROTOBUF_CONSTEXPR CTESearchClause(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CTESearchClause(const CTESearchClause& 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 (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CTESearchClause_default_instance_); } static constexpr int kIndexInFileMessages = 225; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CTESearchClause* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CTESearchClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CTESearchClause& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CTESearchClause& from) { CTESearchClause::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CTESearchClause* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CTESearchClause"; } protected: explicit CTESearchClause(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_search_col_list(); private: const ::pg_query::Node& _internal_search_col_list(int index) const; ::pg_query::Node* _internal_add_search_col_list(); public: const ::pg_query::Node& search_col_list(int index) const; ::pg_query::Node* add_search_col_list(); const ::PROTOBUF_NAMESPACE_ID::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 void set_search_seq_column(ArgT0&& arg0, ArgT... args); std::string* mutable_search_seq_column(); PROTOBUF_NODISCARD std::string* release_search_seq_column(); void set_allocated_search_seq_column(std::string* search_seq_column); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > search_col_list_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr search_seq_column_; bool search_breadth_first_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CTECycleClause final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CTECycleClause) */ { public: inline CTECycleClause() : CTECycleClause(nullptr) {} ~CTECycleClause() override; explicit PROTOBUF_CONSTEXPR CTECycleClause(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CTECycleClause(const CTECycleClause& 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 (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CTECycleClause_default_instance_); } static constexpr int kIndexInFileMessages = 226; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CTECycleClause* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CTECycleClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CTECycleClause& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CTECycleClause& from) { CTECycleClause::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CTECycleClause* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CTECycleClause"; } protected: explicit CTECycleClause(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_cycle_col_list(); private: const ::pg_query::Node& _internal_cycle_col_list(int index) const; ::pg_query::Node* _internal_add_cycle_col_list(); public: const ::pg_query::Node& cycle_col_list(int index) const; ::pg_query::Node* add_cycle_col_list(); const ::PROTOBUF_NAMESPACE_ID::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 void set_cycle_mark_column(ArgT0&& arg0, ArgT... args); std::string* mutable_cycle_mark_column(); PROTOBUF_NODISCARD std::string* release_cycle_mark_column(); void set_allocated_cycle_mark_column(std::string* cycle_mark_column); 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 void set_cycle_path_column(ArgT0&& arg0, ArgT... args); std::string* mutable_cycle_path_column(); PROTOBUF_NODISCARD std::string* release_cycle_path_column(); void set_allocated_cycle_path_column(std::string* cycle_path_column); 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; private: bool _internal_has_cycle_mark_value() const; public: 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* cycle_mark_value); private: const ::pg_query::Node& _internal_cycle_mark_value() const; ::pg_query::Node* _internal_mutable_cycle_mark_value(); public: void unsafe_arena_set_allocated_cycle_mark_value( ::pg_query::Node* cycle_mark_value); ::pg_query::Node* unsafe_arena_release_cycle_mark_value(); // .pg_query.Node cycle_mark_default = 4 [json_name = "cycle_mark_default"]; bool has_cycle_mark_default() const; private: bool _internal_has_cycle_mark_default() const; public: 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* cycle_mark_default); private: const ::pg_query::Node& _internal_cycle_mark_default() const; ::pg_query::Node* _internal_mutable_cycle_mark_default(); public: void unsafe_arena_set_allocated_cycle_mark_default( ::pg_query::Node* cycle_mark_default); ::pg_query::Node* unsafe_arena_release_cycle_mark_default(); // 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > cycle_col_list_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cycle_mark_column_; ::PROTOBUF_NAMESPACE_ID::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_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CommonTableExpr final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CommonTableExpr) */ { public: inline CommonTableExpr() : CommonTableExpr(nullptr) {} ~CommonTableExpr() override; explicit PROTOBUF_CONSTEXPR CommonTableExpr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CommonTableExpr(const CommonTableExpr& from); CommonTableExpr(CommonTableExpr&& from) noexcept : CommonTableExpr() { *this = ::std::move(from); } inline CommonTableExpr& operator=(const CommonTableExpr& from) { CopyFrom(from); return *this; } inline CommonTableExpr& operator=(CommonTableExpr&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CommonTableExpr_default_instance_); } static constexpr int kIndexInFileMessages = 227; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CommonTableExpr* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CommonTableExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CommonTableExpr& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CommonTableExpr& from) { CommonTableExpr::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CommonTableExpr* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CommonTableExpr"; } protected: explicit CommonTableExpr(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_aliascolnames(); private: const ::pg_query::Node& _internal_aliascolnames(int index) const; ::pg_query::Node* _internal_add_aliascolnames(); public: const ::pg_query::Node& aliascolnames(int index) const; ::pg_query::Node* add_aliascolnames(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& aliascolnames() const; // repeated .pg_query.Node ctecolnames = 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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_ctecolnames(); private: const ::pg_query::Node& _internal_ctecolnames(int index) const; ::pg_query::Node* _internal_add_ctecolnames(); public: const ::pg_query::Node& ctecolnames(int index) const; ::pg_query::Node* add_ctecolnames(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& ctecolnames() const; // repeated .pg_query.Node ctecoltypes = 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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_ctecoltypes(); private: const ::pg_query::Node& _internal_ctecoltypes(int index) const; ::pg_query::Node* _internal_add_ctecoltypes(); public: const ::pg_query::Node& ctecoltypes(int index) const; ::pg_query::Node* add_ctecoltypes(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& ctecoltypes() const; // repeated .pg_query.Node ctecoltypmods = 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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_ctecoltypmods(); private: const ::pg_query::Node& _internal_ctecoltypmods(int index) const; ::pg_query::Node* _internal_add_ctecoltypmods(); public: const ::pg_query::Node& ctecoltypmods(int index) const; ::pg_query::Node* add_ctecoltypmods(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& ctecoltypmods() const; // repeated .pg_query.Node ctecolcollations = 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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_ctecolcollations(); private: const ::pg_query::Node& _internal_ctecolcollations(int index) const; ::pg_query::Node* _internal_add_ctecolcollations(); public: const ::pg_query::Node& ctecolcollations(int index) const; ::pg_query::Node* add_ctecolcollations(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& ctecolcollations() const; // string ctename = 1 [json_name = "ctename"]; void clear_ctename(); const std::string& ctename() const; template void set_ctename(ArgT0&& arg0, ArgT... args); std::string* mutable_ctename(); PROTOBUF_NODISCARD std::string* release_ctename(); void set_allocated_ctename(std::string* ctename); 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; private: bool _internal_has_ctequery() const; public: 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* ctequery); private: const ::pg_query::Node& _internal_ctequery() const; ::pg_query::Node* _internal_mutable_ctequery(); public: void unsafe_arena_set_allocated_ctequery( ::pg_query::Node* ctequery); ::pg_query::Node* unsafe_arena_release_ctequery(); // .pg_query.CTESearchClause search_clause = 5 [json_name = "search_clause"]; bool has_search_clause() const; private: bool _internal_has_search_clause() const; public: 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* search_clause); private: const ::pg_query::CTESearchClause& _internal_search_clause() const; ::pg_query::CTESearchClause* _internal_mutable_search_clause(); public: void unsafe_arena_set_allocated_search_clause( ::pg_query::CTESearchClause* search_clause); ::pg_query::CTESearchClause* unsafe_arena_release_search_clause(); // .pg_query.CTECycleClause cycle_clause = 6 [json_name = "cycle_clause"]; bool has_cycle_clause() const; private: bool _internal_has_cycle_clause() const; public: 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* cycle_clause); private: const ::pg_query::CTECycleClause& _internal_cycle_clause() const; ::pg_query::CTECycleClause* _internal_mutable_cycle_clause(); public: void unsafe_arena_set_allocated_cycle_clause( ::pg_query::CTECycleClause* cycle_clause); ::pg_query::CTECycleClause* unsafe_arena_release_cycle_clause(); // .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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > aliascolnames_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > ctecolnames_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > ctecoltypes_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > ctecoltypmods_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > ctecolcollations_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ctename_; ::pg_query::Node* ctequery_; ::pg_query::CTESearchClause* search_clause_; ::pg_query::CTECycleClause* cycle_clause_; int ctematerialized_; int32_t location_; bool cterecursive_; int32_t cterefcount_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class MergeWhenClause final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.MergeWhenClause) */ { public: inline MergeWhenClause() : MergeWhenClause(nullptr) {} ~MergeWhenClause() override; explicit PROTOBUF_CONSTEXPR MergeWhenClause(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); MergeWhenClause(const MergeWhenClause& 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 (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_MergeWhenClause_default_instance_); } static constexpr int kIndexInFileMessages = 228; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(MergeWhenClause* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- MergeWhenClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const MergeWhenClause& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const MergeWhenClause& from) { MergeWhenClause::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(MergeWhenClause* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.MergeWhenClause"; } protected: explicit MergeWhenClause(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_target_list(); private: const ::pg_query::Node& _internal_target_list(int index) const; ::pg_query::Node* _internal_add_target_list(); public: const ::pg_query::Node& target_list(int index) const; ::pg_query::Node* add_target_list(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& target_list() const; // repeated .pg_query.Node 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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_values(); private: const ::pg_query::Node& _internal_values(int index) const; ::pg_query::Node* _internal_add_values(); public: const ::pg_query::Node& values(int index) const; ::pg_query::Node* add_values(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& values() const; // .pg_query.Node condition = 4 [json_name = "condition"]; bool has_condition() const; private: bool _internal_has_condition() const; public: 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* condition); private: const ::pg_query::Node& _internal_condition() const; ::pg_query::Node* _internal_mutable_condition(); public: void unsafe_arena_set_allocated_condition( ::pg_query::Node* condition); ::pg_query::Node* unsafe_arena_release_condition(); // 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > target_list_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > values_; ::pg_query::Node* condition_; bool matched_; int command_type_; int override_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class RoleSpec final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.RoleSpec) */ { public: inline RoleSpec() : RoleSpec(nullptr) {} ~RoleSpec() override; explicit PROTOBUF_CONSTEXPR RoleSpec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); RoleSpec(const RoleSpec& from); RoleSpec(RoleSpec&& from) noexcept : RoleSpec() { *this = ::std::move(from); } inline RoleSpec& operator=(const RoleSpec& from) { CopyFrom(from); return *this; } inline RoleSpec& operator=(RoleSpec&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_RoleSpec_default_instance_); } static constexpr int kIndexInFileMessages = 229; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(RoleSpec* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- RoleSpec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const RoleSpec& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const RoleSpec& from) { RoleSpec::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(RoleSpec* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.RoleSpec"; } protected: explicit RoleSpec(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_rolename(ArgT0&& arg0, ArgT... args); std::string* mutable_rolename(); PROTOBUF_NODISCARD std::string* release_rolename(); void set_allocated_rolename(std::string* rolename); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rolename_; int roletype_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class TriggerTransition final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.TriggerTransition) */ { public: inline TriggerTransition() : TriggerTransition(nullptr) {} ~TriggerTransition() override; explicit PROTOBUF_CONSTEXPR TriggerTransition(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); TriggerTransition(const TriggerTransition& from); TriggerTransition(TriggerTransition&& from) noexcept : TriggerTransition() { *this = ::std::move(from); } inline TriggerTransition& operator=(const TriggerTransition& from) { CopyFrom(from); return *this; } inline TriggerTransition& operator=(TriggerTransition&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_TriggerTransition_default_instance_); } static constexpr int kIndexInFileMessages = 230; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(TriggerTransition* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- TriggerTransition* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const TriggerTransition& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const TriggerTransition& from) { TriggerTransition::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(TriggerTransition* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.TriggerTransition"; } protected: explicit TriggerTransition(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; bool is_new_; bool is_table_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class PartitionElem final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.PartitionElem) */ { public: inline PartitionElem() : PartitionElem(nullptr) {} ~PartitionElem() override; explicit PROTOBUF_CONSTEXPR PartitionElem(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); PartitionElem(const PartitionElem& from); PartitionElem(PartitionElem&& from) noexcept : PartitionElem() { *this = ::std::move(from); } inline PartitionElem& operator=(const PartitionElem& from) { CopyFrom(from); return *this; } inline PartitionElem& operator=(PartitionElem&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_PartitionElem_default_instance_); } static constexpr int kIndexInFileMessages = 231; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PartitionElem* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PartitionElem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const PartitionElem& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const PartitionElem& from) { PartitionElem::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(PartitionElem* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.PartitionElem"; } protected: explicit PartitionElem(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_collation(); private: const ::pg_query::Node& _internal_collation(int index) const; ::pg_query::Node* _internal_add_collation(); public: const ::pg_query::Node& collation(int index) const; ::pg_query::Node* add_collation(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& collation() const; // repeated .pg_query.Node opclass = 4 [json_name = "opclass"]; int opclass_size() const; private: int _internal_opclass_size() const; public: void clear_opclass(); ::pg_query::Node* mutable_opclass(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_opclass(); private: const ::pg_query::Node& _internal_opclass(int index) const; ::pg_query::Node* _internal_add_opclass(); public: const ::pg_query::Node& opclass(int index) const; ::pg_query::Node* add_opclass(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& opclass() const; // string name = 1 [json_name = "name"]; void clear_name(); const std::string& name() const; template void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); 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; private: bool _internal_has_expr() const; public: 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* expr); private: const ::pg_query::Node& _internal_expr() const; ::pg_query::Node* _internal_mutable_expr(); public: void unsafe_arena_set_allocated_expr( ::pg_query::Node* expr); ::pg_query::Node* unsafe_arena_release_expr(); // int32 location = 5 [json_name = "location"]; void clear_location(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > collation_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > opclass_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; ::pg_query::Node* expr_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class PartitionSpec final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.PartitionSpec) */ { public: inline PartitionSpec() : PartitionSpec(nullptr) {} ~PartitionSpec() override; explicit PROTOBUF_CONSTEXPR PartitionSpec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); PartitionSpec(const PartitionSpec& from); PartitionSpec(PartitionSpec&& from) noexcept : PartitionSpec() { *this = ::std::move(from); } inline PartitionSpec& operator=(const PartitionSpec& from) { CopyFrom(from); return *this; } inline PartitionSpec& operator=(PartitionSpec&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_PartitionSpec_default_instance_); } static constexpr int kIndexInFileMessages = 232; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PartitionSpec* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PartitionSpec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const PartitionSpec& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const PartitionSpec& from) { PartitionSpec::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(PartitionSpec* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.PartitionSpec"; } protected: explicit PartitionSpec(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_part_params(); private: const ::pg_query::Node& _internal_part_params(int index) const; ::pg_query::Node* _internal_add_part_params(); public: const ::pg_query::Node& part_params(int index) const; ::pg_query::Node* add_part_params(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& part_params() const; // string strategy = 1 [json_name = "strategy"]; void clear_strategy(); const std::string& strategy() const; template void set_strategy(ArgT0&& arg0, ArgT... args); std::string* mutable_strategy(); PROTOBUF_NODISCARD std::string* release_strategy(); void set_allocated_strategy(std::string* strategy); 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: // 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > part_params_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr strategy_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class PartitionBoundSpec final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.PartitionBoundSpec) */ { public: inline PartitionBoundSpec() : PartitionBoundSpec(nullptr) {} ~PartitionBoundSpec() override; explicit PROTOBUF_CONSTEXPR PartitionBoundSpec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); PartitionBoundSpec(const PartitionBoundSpec& from); PartitionBoundSpec(PartitionBoundSpec&& from) noexcept : PartitionBoundSpec() { *this = ::std::move(from); } inline PartitionBoundSpec& operator=(const PartitionBoundSpec& from) { CopyFrom(from); return *this; } inline PartitionBoundSpec& operator=(PartitionBoundSpec&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_PartitionBoundSpec_default_instance_); } static constexpr int kIndexInFileMessages = 233; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PartitionBoundSpec* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PartitionBoundSpec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const PartitionBoundSpec& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const PartitionBoundSpec& from) { PartitionBoundSpec::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(PartitionBoundSpec* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.PartitionBoundSpec"; } protected: explicit PartitionBoundSpec(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_listdatums(); private: const ::pg_query::Node& _internal_listdatums(int index) const; ::pg_query::Node* _internal_add_listdatums(); public: const ::pg_query::Node& listdatums(int index) const; ::pg_query::Node* add_listdatums(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& listdatums() const; // repeated .pg_query.Node lowerdatums = 6 [json_name = "lowerdatums"]; int lowerdatums_size() const; private: int _internal_lowerdatums_size() const; public: void clear_lowerdatums(); ::pg_query::Node* mutable_lowerdatums(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_lowerdatums(); private: const ::pg_query::Node& _internal_lowerdatums(int index) const; ::pg_query::Node* _internal_add_lowerdatums(); public: const ::pg_query::Node& lowerdatums(int index) const; ::pg_query::Node* add_lowerdatums(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& lowerdatums() const; // repeated .pg_query.Node upperdatums = 7 [json_name = "upperdatums"]; int upperdatums_size() const; private: int _internal_upperdatums_size() const; public: void clear_upperdatums(); ::pg_query::Node* mutable_upperdatums(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_upperdatums(); private: const ::pg_query::Node& _internal_upperdatums(int index) const; ::pg_query::Node* _internal_add_upperdatums(); public: const ::pg_query::Node& upperdatums(int index) const; ::pg_query::Node* add_upperdatums(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& upperdatums() const; // string strategy = 1 [json_name = "strategy"]; void clear_strategy(); const std::string& strategy() const; template void set_strategy(ArgT0&& arg0, ArgT... args); std::string* mutable_strategy(); PROTOBUF_NODISCARD std::string* release_strategy(); void set_allocated_strategy(std::string* strategy); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > listdatums_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > lowerdatums_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > upperdatums_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr strategy_; bool is_default_; int32_t modulus_; int32_t remainder_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class PartitionRangeDatum final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.PartitionRangeDatum) */ { public: inline PartitionRangeDatum() : PartitionRangeDatum(nullptr) {} ~PartitionRangeDatum() override; explicit PROTOBUF_CONSTEXPR PartitionRangeDatum(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); PartitionRangeDatum(const PartitionRangeDatum& from); PartitionRangeDatum(PartitionRangeDatum&& from) noexcept : PartitionRangeDatum() { *this = ::std::move(from); } inline PartitionRangeDatum& operator=(const PartitionRangeDatum& from) { CopyFrom(from); return *this; } inline PartitionRangeDatum& operator=(PartitionRangeDatum&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_PartitionRangeDatum_default_instance_); } static constexpr int kIndexInFileMessages = 234; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PartitionRangeDatum* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PartitionRangeDatum* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const PartitionRangeDatum& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const PartitionRangeDatum& from) { PartitionRangeDatum::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(PartitionRangeDatum* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.PartitionRangeDatum"; } protected: explicit PartitionRangeDatum(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_value() const; public: 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); private: const ::pg_query::Node& _internal_value() const; ::pg_query::Node* _internal_mutable_value(); public: void unsafe_arena_set_allocated_value( ::pg_query::Node* value); ::pg_query::Node* unsafe_arena_release_value(); // .pg_query.PartitionRangeDatumKind kind = 1 [json_name = "kind"]; void clear_kind(); ::pg_query::PartitionRangeDatumKind kind() const; void set_kind(::pg_query::PartitionRangeDatumKind value); private: ::pg_query::PartitionRangeDatumKind _internal_kind() const; void _internal_set_kind(::pg_query::PartitionRangeDatumKind value); public: // int32 location = 3 [json_name = "location"]; void clear_location(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::Node* value_; int kind_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class PartitionCmd final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.PartitionCmd) */ { public: inline PartitionCmd() : PartitionCmd(nullptr) {} ~PartitionCmd() override; explicit PROTOBUF_CONSTEXPR PartitionCmd(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); PartitionCmd(const PartitionCmd& from); PartitionCmd(PartitionCmd&& from) noexcept : PartitionCmd() { *this = ::std::move(from); } inline PartitionCmd& operator=(const PartitionCmd& from) { CopyFrom(from); return *this; } inline PartitionCmd& operator=(PartitionCmd&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_PartitionCmd_default_instance_); } static constexpr int kIndexInFileMessages = 235; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PartitionCmd* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PartitionCmd* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const PartitionCmd& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const PartitionCmd& from) { PartitionCmd::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(PartitionCmd* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.PartitionCmd"; } protected: explicit PartitionCmd(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; private: bool _internal_has_name() const; public: 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* name); private: const ::pg_query::RangeVar& _internal_name() const; ::pg_query::RangeVar* _internal_mutable_name(); public: void unsafe_arena_set_allocated_name( ::pg_query::RangeVar* name); ::pg_query::RangeVar* unsafe_arena_release_name(); // .pg_query.PartitionBoundSpec bound = 2 [json_name = "bound"]; bool has_bound() const; private: bool _internal_has_bound() const; public: void clear_bound(); const ::pg_query::PartitionBoundSpec& bound() const; PROTOBUF_NODISCARD ::pg_query::PartitionBoundSpec* release_bound(); ::pg_query::PartitionBoundSpec* mutable_bound(); void set_allocated_bound(::pg_query::PartitionBoundSpec* bound); private: const ::pg_query::PartitionBoundSpec& _internal_bound() const; ::pg_query::PartitionBoundSpec* _internal_mutable_bound(); public: void unsafe_arena_set_allocated_bound( ::pg_query::PartitionBoundSpec* bound); ::pg_query::PartitionBoundSpec* unsafe_arena_release_bound(); // 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::pg_query::RangeVar* name_; ::pg_query::PartitionBoundSpec* bound_; bool concurrent_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class VacuumRelation final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.VacuumRelation) */ { public: inline VacuumRelation() : VacuumRelation(nullptr) {} ~VacuumRelation() override; explicit PROTOBUF_CONSTEXPR VacuumRelation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); VacuumRelation(const VacuumRelation& from); VacuumRelation(VacuumRelation&& from) noexcept : VacuumRelation() { *this = ::std::move(from); } inline VacuumRelation& operator=(const VacuumRelation& from) { CopyFrom(from); return *this; } inline VacuumRelation& operator=(VacuumRelation&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_VacuumRelation_default_instance_); } static constexpr int kIndexInFileMessages = 236; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(VacuumRelation* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- VacuumRelation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const VacuumRelation& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const VacuumRelation& from) { VacuumRelation::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(VacuumRelation* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.VacuumRelation"; } protected: explicit VacuumRelation(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_va_cols(); private: const ::pg_query::Node& _internal_va_cols(int index) const; ::pg_query::Node* _internal_add_va_cols(); public: const ::pg_query::Node& va_cols(int index) const; ::pg_query::Node* add_va_cols(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& va_cols() const; // .pg_query.RangeVar relation = 1 [json_name = "relation"]; bool has_relation() const; private: bool _internal_has_relation() const; public: void clear_relation(); const ::pg_query::RangeVar& relation() const; PROTOBUF_NODISCARD ::pg_query::RangeVar* release_relation(); ::pg_query::RangeVar* mutable_relation(); void set_allocated_relation(::pg_query::RangeVar* relation); private: const ::pg_query::RangeVar& _internal_relation() const; ::pg_query::RangeVar* _internal_mutable_relation(); public: void unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation); ::pg_query::RangeVar* unsafe_arena_release_relation(); // uint32 oid = 2 [json_name = "oid"]; void clear_oid(); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > va_cols_; ::pg_query::RangeVar* relation_; uint32_t oid_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class PublicationObjSpec final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.PublicationObjSpec) */ { public: inline PublicationObjSpec() : PublicationObjSpec(nullptr) {} ~PublicationObjSpec() override; explicit PROTOBUF_CONSTEXPR PublicationObjSpec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); PublicationObjSpec(const PublicationObjSpec& 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 (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_PublicationObjSpec_default_instance_); } static constexpr int kIndexInFileMessages = 237; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PublicationObjSpec* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PublicationObjSpec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const PublicationObjSpec& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const PublicationObjSpec& from) { PublicationObjSpec::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(PublicationObjSpec* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.PublicationObjSpec"; } protected: explicit PublicationObjSpec(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); 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; private: bool _internal_has_pubtable() const; public: 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* pubtable); private: const ::pg_query::PublicationTable& _internal_pubtable() const; ::pg_query::PublicationTable* _internal_mutable_pubtable(); public: void unsafe_arena_set_allocated_pubtable( ::pg_query::PublicationTable* pubtable); ::pg_query::PublicationTable* unsafe_arena_release_pubtable(); // .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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; ::pg_query::PublicationTable* pubtable_; int pubobjtype_; int32_t location_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class PublicationTable final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.PublicationTable) */ { public: inline PublicationTable() : PublicationTable(nullptr) {} ~PublicationTable() override; explicit PROTOBUF_CONSTEXPR PublicationTable(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); PublicationTable(const PublicationTable& 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 (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_PublicationTable_default_instance_); } static constexpr int kIndexInFileMessages = 238; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PublicationTable* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- PublicationTable* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const PublicationTable& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const PublicationTable& from) { PublicationTable::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(PublicationTable* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.PublicationTable"; } protected: explicit PublicationTable(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* mutable_columns(); private: const ::pg_query::Node& _internal_columns(int index) const; ::pg_query::Node* _internal_add_columns(); public: const ::pg_query::Node& columns(int index) const; ::pg_query::Node* add_columns(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& columns() const; // .pg_query.RangeVar relation = 1 [json_name = "relation"]; bool has_relation() const; private: bool _internal_has_relation() const; public: void clear_relation(); const ::pg_query::RangeVar& relation() const; PROTOBUF_NODISCARD ::pg_query::RangeVar* release_relation(); ::pg_query::RangeVar* mutable_relation(); void set_allocated_relation(::pg_query::RangeVar* relation); private: const ::pg_query::RangeVar& _internal_relation() const; ::pg_query::RangeVar* _internal_mutable_relation(); public: void unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation); ::pg_query::RangeVar* unsafe_arena_release_relation(); // .pg_query.Node where_clause = 2 [json_name = "whereClause"]; bool has_where_clause() const; private: bool _internal_has_where_clause() const; public: void clear_where_clause(); const ::pg_query::Node& where_clause() const; PROTOBUF_NODISCARD ::pg_query::Node* release_where_clause(); ::pg_query::Node* mutable_where_clause(); void set_allocated_where_clause(::pg_query::Node* where_clause); private: const ::pg_query::Node& _internal_where_clause() const; ::pg_query::Node* _internal_mutable_where_clause(); public: void unsafe_arena_set_allocated_where_clause( ::pg_query::Node* where_clause); ::pg_query::Node* unsafe_arena_release_where_clause(); // @@protoc_insertion_point(class_scope:pg_query.PublicationTable) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node > columns_; ::pg_query::RangeVar* relation_; ::pg_query::Node* where_clause_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class InlineCodeBlock final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.InlineCodeBlock) */ { public: inline InlineCodeBlock() : InlineCodeBlock(nullptr) {} ~InlineCodeBlock() override; explicit PROTOBUF_CONSTEXPR InlineCodeBlock(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); InlineCodeBlock(const InlineCodeBlock& from); InlineCodeBlock(InlineCodeBlock&& from) noexcept : InlineCodeBlock() { *this = ::std::move(from); } inline InlineCodeBlock& operator=(const InlineCodeBlock& from) { CopyFrom(from); return *this; } inline InlineCodeBlock& operator=(InlineCodeBlock&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_InlineCodeBlock_default_instance_); } static constexpr int kIndexInFileMessages = 239; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(InlineCodeBlock* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- InlineCodeBlock* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const InlineCodeBlock& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const InlineCodeBlock& from) { InlineCodeBlock::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(InlineCodeBlock* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.InlineCodeBlock"; } protected: explicit InlineCodeBlock(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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 void set_source_text(ArgT0&& arg0, ArgT... args); std::string* mutable_source_text(); PROTOBUF_NODISCARD std::string* release_source_text(); void set_allocated_source_text(std::string* source_text); 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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_text_; uint32_t lang_oid_; bool lang_is_trusted_; bool atomic_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class CallContext final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.CallContext) */ { public: inline CallContext() : CallContext(nullptr) {} ~CallContext() override; explicit PROTOBUF_CONSTEXPR CallContext(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CallContext(const CallContext& from); CallContext(CallContext&& from) noexcept : CallContext() { *this = ::std::move(from); } inline CallContext& operator=(const CallContext& from) { CopyFrom(from); return *this; } inline CallContext& operator=(CallContext&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_CallContext_default_instance_); } static constexpr int kIndexInFileMessages = 240; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CallContext* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CallContext* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CallContext& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CallContext& from) { CallContext::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CallContext* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.CallContext"; } protected: explicit CallContext(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { bool atomic_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_protobuf_2fpg_5fquery_2eproto; }; // ------------------------------------------------------------------- class ScanToken final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pg_query.ScanToken) */ { public: inline ScanToken() : ScanToken(nullptr) {} ~ScanToken() override; explicit PROTOBUF_CONSTEXPR ScanToken(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ScanToken(const ScanToken& from); ScanToken(ScanToken&& from) noexcept : ScanToken() { *this = ::std::move(from); } inline ScanToken& operator=(const ScanToken& from) { CopyFrom(from); return *this; } inline ScanToken& operator=(ScanToken&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::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( &_ScanToken_default_instance_); } static constexpr int kIndexInFileMessages = 241; 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 (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ScanToken* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ScanToken* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ScanToken& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ScanToken& from) { ScanToken::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::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, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ScanToken* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "pg_query.ScanToken"; } protected: explicit ScanToken(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::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; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { int32_t start_; int32_t end_; int token_; int keyword_kind_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; 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() { _impl_.version_ = 0; } inline int32_t ParseResult::_internal_version() const { return _impl_.version_; } inline int32_t ParseResult::version() const { // @@protoc_insertion_point(field_get:pg_query.ParseResult.version) return _internal_version(); } inline void ParseResult::_internal_set_version(int32_t value) { _impl_.version_ = value; } inline void ParseResult::set_version(int32_t value) { _internal_set_version(value); // @@protoc_insertion_point(field_set:pg_query.ParseResult.version) } // repeated .pg_query.RawStmt stmts = 2; inline int ParseResult::_internal_stmts_size() const { return _impl_.stmts_.size(); } inline int ParseResult::stmts_size() const { return _internal_stmts_size(); } inline void ParseResult::clear_stmts() { _impl_.stmts_.Clear(); } inline ::pg_query::RawStmt* ParseResult::mutable_stmts(int index) { // @@protoc_insertion_point(field_mutable:pg_query.ParseResult.stmts) return _impl_.stmts_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::RawStmt >* ParseResult::mutable_stmts() { // @@protoc_insertion_point(field_mutable_list:pg_query.ParseResult.stmts) return &_impl_.stmts_; } inline const ::pg_query::RawStmt& ParseResult::_internal_stmts(int index) const { return _impl_.stmts_.Get(index); } inline const ::pg_query::RawStmt& ParseResult::stmts(int index) const { // @@protoc_insertion_point(field_get:pg_query.ParseResult.stmts) return _internal_stmts(index); } inline ::pg_query::RawStmt* ParseResult::_internal_add_stmts() { return _impl_.stmts_.Add(); } inline ::pg_query::RawStmt* ParseResult::add_stmts() { ::pg_query::RawStmt* _add = _internal_add_stmts(); // @@protoc_insertion_point(field_add:pg_query.ParseResult.stmts) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::RawStmt >& ParseResult::stmts() const { // @@protoc_insertion_point(field_list:pg_query.ParseResult.stmts) return _impl_.stmts_; } // ------------------------------------------------------------------- // ScanResult // int32 version = 1; inline void ScanResult::clear_version() { _impl_.version_ = 0; } inline int32_t ScanResult::_internal_version() const { return _impl_.version_; } inline int32_t ScanResult::version() const { // @@protoc_insertion_point(field_get:pg_query.ScanResult.version) return _internal_version(); } inline void ScanResult::_internal_set_version(int32_t value) { _impl_.version_ = value; } inline void ScanResult::set_version(int32_t value) { _internal_set_version(value); // @@protoc_insertion_point(field_set:pg_query.ScanResult.version) } // repeated .pg_query.ScanToken tokens = 2; inline int ScanResult::_internal_tokens_size() const { return _impl_.tokens_.size(); } inline int ScanResult::tokens_size() const { return _internal_tokens_size(); } inline void ScanResult::clear_tokens() { _impl_.tokens_.Clear(); } inline ::pg_query::ScanToken* ScanResult::mutable_tokens(int index) { // @@protoc_insertion_point(field_mutable:pg_query.ScanResult.tokens) return _impl_.tokens_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::ScanToken >* ScanResult::mutable_tokens() { // @@protoc_insertion_point(field_mutable_list:pg_query.ScanResult.tokens) return &_impl_.tokens_; } inline const ::pg_query::ScanToken& ScanResult::_internal_tokens(int index) const { return _impl_.tokens_.Get(index); } inline const ::pg_query::ScanToken& ScanResult::tokens(int index) const { // @@protoc_insertion_point(field_get:pg_query.ScanResult.tokens) return _internal_tokens(index); } inline ::pg_query::ScanToken* ScanResult::_internal_add_tokens() { return _impl_.tokens_.Add(); } inline ::pg_query::ScanToken* ScanResult::add_tokens() { ::pg_query::ScanToken* _add = _internal_add_tokens(); // @@protoc_insertion_point(field_add:pg_query.ScanResult.tokens) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::ScanToken >& ScanResult::tokens() const { // @@protoc_insertion_point(field_list:pg_query.ScanResult.tokens) return _impl_.tokens_; } // ------------------------------------------------------------------- // Node // .pg_query.Alias alias = 1 [json_name = "Alias"]; inline bool Node::_internal_has_alias() const { return node_case() == kAlias; } inline bool Node::has_alias() const { return _internal_has_alias(); } inline void Node::set_has_alias() { _impl_._oneof_case_[0] = kAlias; } inline void Node::clear_alias() { if (_internal_has_alias()) { if (GetArenaForAllocation() == 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 (_internal_has_alias()) { clear_has_node(); ::pg_query::Alias* temp = _impl_.node_.alias_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.alias_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::Alias& Node::_internal_alias() const { return _internal_has_alias() ? *_impl_.node_.alias_ : reinterpret_cast< ::pg_query::Alias&>(::pg_query::_Alias_default_instance_); } inline const ::pg_query::Alias& Node::alias() const { // @@protoc_insertion_point(field_get:pg_query.Node.alias) return _internal_alias(); } inline ::pg_query::Alias* Node::unsafe_arena_release_alias() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alias) if (_internal_has_alias()) { clear_has_node(); ::pg_query::Alias* temp = _impl_.node_.alias_; _impl_.node_.alias_ = nullptr; return temp; } else { return nullptr; } } inline void Node::unsafe_arena_set_allocated_alias(::pg_query::Alias* alias) { clear_node(); if (alias) { set_has_alias(); _impl_.node_.alias_ = alias; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alias) } inline ::pg_query::Alias* Node::_internal_mutable_alias() { if (!_internal_has_alias()) { clear_node(); set_has_alias(); _impl_.node_.alias_ = CreateMaybeMessage< ::pg_query::Alias >(GetArenaForAllocation()); } return _impl_.node_.alias_; } inline ::pg_query::Alias* Node::mutable_alias() { ::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::_internal_has_range_var() const { return node_case() == kRangeVar; } inline bool Node::has_range_var() const { return _internal_has_range_var(); } inline void Node::set_has_range_var() { _impl_._oneof_case_[0] = kRangeVar; } inline void Node::clear_range_var() { if (_internal_has_range_var()) { if (GetArenaForAllocation() == 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 (_internal_has_range_var()) { clear_has_node(); ::pg_query::RangeVar* temp = _impl_.node_.range_var_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.range_var_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::RangeVar& Node::_internal_range_var() const { return _internal_has_range_var() ? *_impl_.node_.range_var_ : reinterpret_cast< ::pg_query::RangeVar&>(::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& Node::range_var() const { // @@protoc_insertion_point(field_get:pg_query.Node.range_var) return _internal_range_var(); } inline ::pg_query::RangeVar* Node::unsafe_arena_release_range_var() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.range_var) if (_internal_has_range_var()) { clear_has_node(); ::pg_query::RangeVar* temp = _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* range_var) { clear_node(); if (range_var) { set_has_range_var(); _impl_.node_.range_var_ = range_var; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.range_var) } inline ::pg_query::RangeVar* Node::_internal_mutable_range_var() { if (!_internal_has_range_var()) { clear_node(); set_has_range_var(); _impl_.node_.range_var_ = CreateMaybeMessage< ::pg_query::RangeVar >(GetArenaForAllocation()); } return _impl_.node_.range_var_; } inline ::pg_query::RangeVar* Node::mutable_range_var() { ::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::_internal_has_table_func() const { return node_case() == kTableFunc; } inline bool Node::has_table_func() const { return _internal_has_table_func(); } inline void Node::set_has_table_func() { _impl_._oneof_case_[0] = kTableFunc; } inline void Node::clear_table_func() { if (_internal_has_table_func()) { if (GetArenaForAllocation() == 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 (_internal_has_table_func()) { clear_has_node(); ::pg_query::TableFunc* temp = _impl_.node_.table_func_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.table_func_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::TableFunc& Node::_internal_table_func() const { return _internal_has_table_func() ? *_impl_.node_.table_func_ : reinterpret_cast< ::pg_query::TableFunc&>(::pg_query::_TableFunc_default_instance_); } inline const ::pg_query::TableFunc& Node::table_func() const { // @@protoc_insertion_point(field_get:pg_query.Node.table_func) return _internal_table_func(); } inline ::pg_query::TableFunc* Node::unsafe_arena_release_table_func() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.table_func) if (_internal_has_table_func()) { clear_has_node(); ::pg_query::TableFunc* temp = _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* table_func) { clear_node(); if (table_func) { set_has_table_func(); _impl_.node_.table_func_ = table_func; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.table_func) } inline ::pg_query::TableFunc* Node::_internal_mutable_table_func() { if (!_internal_has_table_func()) { clear_node(); set_has_table_func(); _impl_.node_.table_func_ = CreateMaybeMessage< ::pg_query::TableFunc >(GetArenaForAllocation()); } return _impl_.node_.table_func_; } inline ::pg_query::TableFunc* Node::mutable_table_func() { ::pg_query::TableFunc* _msg = _internal_mutable_table_func(); // @@protoc_insertion_point(field_mutable:pg_query.Node.table_func) return _msg; } // .pg_query.Var var = 4 [json_name = "Var"]; inline bool Node::_internal_has_var() const { return node_case() == kVar; } inline bool Node::has_var() const { return _internal_has_var(); } inline void Node::set_has_var() { _impl_._oneof_case_[0] = kVar; } inline void Node::clear_var() { if (_internal_has_var()) { if (GetArenaForAllocation() == 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 (_internal_has_var()) { clear_has_node(); ::pg_query::Var* temp = _impl_.node_.var_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.var_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::Var& Node::_internal_var() const { return _internal_has_var() ? *_impl_.node_.var_ : reinterpret_cast< ::pg_query::Var&>(::pg_query::_Var_default_instance_); } inline const ::pg_query::Var& Node::var() const { // @@protoc_insertion_point(field_get:pg_query.Node.var) return _internal_var(); } inline ::pg_query::Var* Node::unsafe_arena_release_var() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.var) if (_internal_has_var()) { clear_has_node(); ::pg_query::Var* temp = _impl_.node_.var_; _impl_.node_.var_ = nullptr; return temp; } else { return nullptr; } } inline void Node::unsafe_arena_set_allocated_var(::pg_query::Var* var) { clear_node(); if (var) { set_has_var(); _impl_.node_.var_ = var; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.var) } inline ::pg_query::Var* Node::_internal_mutable_var() { if (!_internal_has_var()) { clear_node(); set_has_var(); _impl_.node_.var_ = CreateMaybeMessage< ::pg_query::Var >(GetArenaForAllocation()); } return _impl_.node_.var_; } inline ::pg_query::Var* Node::mutable_var() { ::pg_query::Var* _msg = _internal_mutable_var(); // @@protoc_insertion_point(field_mutable:pg_query.Node.var) return _msg; } // .pg_query.Param param = 5 [json_name = "Param"]; inline bool Node::_internal_has_param() const { return node_case() == kParam; } inline bool Node::has_param() const { return _internal_has_param(); } inline void Node::set_has_param() { _impl_._oneof_case_[0] = kParam; } inline void Node::clear_param() { if (_internal_has_param()) { if (GetArenaForAllocation() == 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 (_internal_has_param()) { clear_has_node(); ::pg_query::Param* temp = _impl_.node_.param_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.param_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::Param& Node::_internal_param() const { return _internal_has_param() ? *_impl_.node_.param_ : reinterpret_cast< ::pg_query::Param&>(::pg_query::_Param_default_instance_); } inline const ::pg_query::Param& Node::param() const { // @@protoc_insertion_point(field_get:pg_query.Node.param) return _internal_param(); } inline ::pg_query::Param* Node::unsafe_arena_release_param() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.param) if (_internal_has_param()) { clear_has_node(); ::pg_query::Param* temp = _impl_.node_.param_; _impl_.node_.param_ = nullptr; return temp; } else { return nullptr; } } inline void Node::unsafe_arena_set_allocated_param(::pg_query::Param* param) { clear_node(); if (param) { set_has_param(); _impl_.node_.param_ = param; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.param) } inline ::pg_query::Param* Node::_internal_mutable_param() { if (!_internal_has_param()) { clear_node(); set_has_param(); _impl_.node_.param_ = CreateMaybeMessage< ::pg_query::Param >(GetArenaForAllocation()); } return _impl_.node_.param_; } inline ::pg_query::Param* Node::mutable_param() { ::pg_query::Param* _msg = _internal_mutable_param(); // @@protoc_insertion_point(field_mutable:pg_query.Node.param) return _msg; } // .pg_query.Aggref aggref = 6 [json_name = "Aggref"]; inline bool Node::_internal_has_aggref() const { return node_case() == kAggref; } inline bool Node::has_aggref() const { return _internal_has_aggref(); } inline void Node::set_has_aggref() { _impl_._oneof_case_[0] = kAggref; } inline void Node::clear_aggref() { if (_internal_has_aggref()) { if (GetArenaForAllocation() == 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 (_internal_has_aggref()) { clear_has_node(); ::pg_query::Aggref* temp = _impl_.node_.aggref_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.aggref_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::Aggref& Node::_internal_aggref() const { return _internal_has_aggref() ? *_impl_.node_.aggref_ : reinterpret_cast< ::pg_query::Aggref&>(::pg_query::_Aggref_default_instance_); } inline const ::pg_query::Aggref& Node::aggref() const { // @@protoc_insertion_point(field_get:pg_query.Node.aggref) return _internal_aggref(); } inline ::pg_query::Aggref* Node::unsafe_arena_release_aggref() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.aggref) if (_internal_has_aggref()) { clear_has_node(); ::pg_query::Aggref* temp = _impl_.node_.aggref_; _impl_.node_.aggref_ = nullptr; return temp; } else { return nullptr; } } inline void Node::unsafe_arena_set_allocated_aggref(::pg_query::Aggref* aggref) { clear_node(); if (aggref) { set_has_aggref(); _impl_.node_.aggref_ = aggref; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.aggref) } inline ::pg_query::Aggref* Node::_internal_mutable_aggref() { if (!_internal_has_aggref()) { clear_node(); set_has_aggref(); _impl_.node_.aggref_ = CreateMaybeMessage< ::pg_query::Aggref >(GetArenaForAllocation()); } return _impl_.node_.aggref_; } inline ::pg_query::Aggref* Node::mutable_aggref() { ::pg_query::Aggref* _msg = _internal_mutable_aggref(); // @@protoc_insertion_point(field_mutable:pg_query.Node.aggref) return _msg; } // .pg_query.GroupingFunc grouping_func = 7 [json_name = "GroupingFunc"]; inline bool Node::_internal_has_grouping_func() const { return node_case() == kGroupingFunc; } inline bool Node::has_grouping_func() const { return _internal_has_grouping_func(); } inline void Node::set_has_grouping_func() { _impl_._oneof_case_[0] = kGroupingFunc; } inline void Node::clear_grouping_func() { if (_internal_has_grouping_func()) { if (GetArenaForAllocation() == 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 (_internal_has_grouping_func()) { clear_has_node(); ::pg_query::GroupingFunc* temp = _impl_.node_.grouping_func_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.grouping_func_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::GroupingFunc& Node::_internal_grouping_func() const { return _internal_has_grouping_func() ? *_impl_.node_.grouping_func_ : reinterpret_cast< ::pg_query::GroupingFunc&>(::pg_query::_GroupingFunc_default_instance_); } inline const ::pg_query::GroupingFunc& Node::grouping_func() const { // @@protoc_insertion_point(field_get:pg_query.Node.grouping_func) return _internal_grouping_func(); } inline ::pg_query::GroupingFunc* Node::unsafe_arena_release_grouping_func() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.grouping_func) if (_internal_has_grouping_func()) { clear_has_node(); ::pg_query::GroupingFunc* temp = _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* grouping_func) { clear_node(); if (grouping_func) { set_has_grouping_func(); _impl_.node_.grouping_func_ = grouping_func; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.grouping_func) } inline ::pg_query::GroupingFunc* Node::_internal_mutable_grouping_func() { if (!_internal_has_grouping_func()) { clear_node(); set_has_grouping_func(); _impl_.node_.grouping_func_ = CreateMaybeMessage< ::pg_query::GroupingFunc >(GetArenaForAllocation()); } return _impl_.node_.grouping_func_; } inline ::pg_query::GroupingFunc* Node::mutable_grouping_func() { ::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 = 8 [json_name = "WindowFunc"]; inline bool Node::_internal_has_window_func() const { return node_case() == kWindowFunc; } inline bool Node::has_window_func() const { return _internal_has_window_func(); } inline void Node::set_has_window_func() { _impl_._oneof_case_[0] = kWindowFunc; } inline void Node::clear_window_func() { if (_internal_has_window_func()) { if (GetArenaForAllocation() == 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 (_internal_has_window_func()) { clear_has_node(); ::pg_query::WindowFunc* temp = _impl_.node_.window_func_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.window_func_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::WindowFunc& Node::_internal_window_func() const { return _internal_has_window_func() ? *_impl_.node_.window_func_ : reinterpret_cast< ::pg_query::WindowFunc&>(::pg_query::_WindowFunc_default_instance_); } inline const ::pg_query::WindowFunc& Node::window_func() const { // @@protoc_insertion_point(field_get:pg_query.Node.window_func) return _internal_window_func(); } inline ::pg_query::WindowFunc* Node::unsafe_arena_release_window_func() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.window_func) if (_internal_has_window_func()) { clear_has_node(); ::pg_query::WindowFunc* temp = _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* window_func) { clear_node(); if (window_func) { set_has_window_func(); _impl_.node_.window_func_ = window_func; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.window_func) } inline ::pg_query::WindowFunc* Node::_internal_mutable_window_func() { if (!_internal_has_window_func()) { clear_node(); set_has_window_func(); _impl_.node_.window_func_ = CreateMaybeMessage< ::pg_query::WindowFunc >(GetArenaForAllocation()); } return _impl_.node_.window_func_; } inline ::pg_query::WindowFunc* Node::mutable_window_func() { ::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 = 9 [json_name = "SubscriptingRef"]; inline bool Node::_internal_has_subscripting_ref() const { return node_case() == kSubscriptingRef; } inline bool Node::has_subscripting_ref() const { return _internal_has_subscripting_ref(); } inline void Node::set_has_subscripting_ref() { _impl_._oneof_case_[0] = kSubscriptingRef; } inline void Node::clear_subscripting_ref() { if (_internal_has_subscripting_ref()) { if (GetArenaForAllocation() == 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 (_internal_has_subscripting_ref()) { clear_has_node(); ::pg_query::SubscriptingRef* temp = _impl_.node_.subscripting_ref_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.subscripting_ref_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::SubscriptingRef& Node::_internal_subscripting_ref() const { return _internal_has_subscripting_ref() ? *_impl_.node_.subscripting_ref_ : reinterpret_cast< ::pg_query::SubscriptingRef&>(::pg_query::_SubscriptingRef_default_instance_); } inline const ::pg_query::SubscriptingRef& Node::subscripting_ref() const { // @@protoc_insertion_point(field_get:pg_query.Node.subscripting_ref) return _internal_subscripting_ref(); } inline ::pg_query::SubscriptingRef* Node::unsafe_arena_release_subscripting_ref() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.subscripting_ref) if (_internal_has_subscripting_ref()) { clear_has_node(); ::pg_query::SubscriptingRef* temp = _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* subscripting_ref) { clear_node(); if (subscripting_ref) { set_has_subscripting_ref(); _impl_.node_.subscripting_ref_ = subscripting_ref; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.subscripting_ref) } inline ::pg_query::SubscriptingRef* Node::_internal_mutable_subscripting_ref() { if (!_internal_has_subscripting_ref()) { clear_node(); set_has_subscripting_ref(); _impl_.node_.subscripting_ref_ = CreateMaybeMessage< ::pg_query::SubscriptingRef >(GetArenaForAllocation()); } return _impl_.node_.subscripting_ref_; } inline ::pg_query::SubscriptingRef* Node::mutable_subscripting_ref() { ::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 = 10 [json_name = "FuncExpr"]; inline bool Node::_internal_has_func_expr() const { return node_case() == kFuncExpr; } inline bool Node::has_func_expr() const { return _internal_has_func_expr(); } inline void Node::set_has_func_expr() { _impl_._oneof_case_[0] = kFuncExpr; } inline void Node::clear_func_expr() { if (_internal_has_func_expr()) { if (GetArenaForAllocation() == 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 (_internal_has_func_expr()) { clear_has_node(); ::pg_query::FuncExpr* temp = _impl_.node_.func_expr_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.func_expr_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::FuncExpr& Node::_internal_func_expr() const { return _internal_has_func_expr() ? *_impl_.node_.func_expr_ : reinterpret_cast< ::pg_query::FuncExpr&>(::pg_query::_FuncExpr_default_instance_); } inline const ::pg_query::FuncExpr& Node::func_expr() const { // @@protoc_insertion_point(field_get:pg_query.Node.func_expr) return _internal_func_expr(); } inline ::pg_query::FuncExpr* Node::unsafe_arena_release_func_expr() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.func_expr) if (_internal_has_func_expr()) { clear_has_node(); ::pg_query::FuncExpr* temp = _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* func_expr) { clear_node(); if (func_expr) { set_has_func_expr(); _impl_.node_.func_expr_ = func_expr; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.func_expr) } inline ::pg_query::FuncExpr* Node::_internal_mutable_func_expr() { if (!_internal_has_func_expr()) { clear_node(); set_has_func_expr(); _impl_.node_.func_expr_ = CreateMaybeMessage< ::pg_query::FuncExpr >(GetArenaForAllocation()); } return _impl_.node_.func_expr_; } inline ::pg_query::FuncExpr* Node::mutable_func_expr() { ::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 = 11 [json_name = "NamedArgExpr"]; inline bool Node::_internal_has_named_arg_expr() const { return node_case() == kNamedArgExpr; } inline bool Node::has_named_arg_expr() const { return _internal_has_named_arg_expr(); } inline void Node::set_has_named_arg_expr() { _impl_._oneof_case_[0] = kNamedArgExpr; } inline void Node::clear_named_arg_expr() { if (_internal_has_named_arg_expr()) { if (GetArenaForAllocation() == 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 (_internal_has_named_arg_expr()) { clear_has_node(); ::pg_query::NamedArgExpr* temp = _impl_.node_.named_arg_expr_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_named_arg_expr() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.named_arg_expr) return _internal_named_arg_expr(); } inline ::pg_query::NamedArgExpr* Node::unsafe_arena_release_named_arg_expr() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.named_arg_expr) if (_internal_has_named_arg_expr()) { clear_has_node(); ::pg_query::NamedArgExpr* temp = _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* named_arg_expr) { clear_node(); if (named_arg_expr) { set_has_named_arg_expr(); _impl_.node_.named_arg_expr_ = named_arg_expr; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.named_arg_expr) } inline ::pg_query::NamedArgExpr* Node::_internal_mutable_named_arg_expr() { if (!_internal_has_named_arg_expr()) { clear_node(); set_has_named_arg_expr(); _impl_.node_.named_arg_expr_ = CreateMaybeMessage< ::pg_query::NamedArgExpr >(GetArenaForAllocation()); } return _impl_.node_.named_arg_expr_; } inline ::pg_query::NamedArgExpr* Node::mutable_named_arg_expr() { ::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 = 12 [json_name = "OpExpr"]; inline bool Node::_internal_has_op_expr() const { return node_case() == kOpExpr; } inline bool Node::has_op_expr() const { return _internal_has_op_expr(); } inline void Node::set_has_op_expr() { _impl_._oneof_case_[0] = kOpExpr; } inline void Node::clear_op_expr() { if (_internal_has_op_expr()) { if (GetArenaForAllocation() == 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 (_internal_has_op_expr()) { clear_has_node(); ::pg_query::OpExpr* temp = _impl_.node_.op_expr_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.op_expr_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::OpExpr& Node::_internal_op_expr() const { return _internal_has_op_expr() ? *_impl_.node_.op_expr_ : reinterpret_cast< ::pg_query::OpExpr&>(::pg_query::_OpExpr_default_instance_); } inline const ::pg_query::OpExpr& Node::op_expr() const { // @@protoc_insertion_point(field_get:pg_query.Node.op_expr) return _internal_op_expr(); } inline ::pg_query::OpExpr* Node::unsafe_arena_release_op_expr() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.op_expr) if (_internal_has_op_expr()) { clear_has_node(); ::pg_query::OpExpr* temp = _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* op_expr) { clear_node(); if (op_expr) { set_has_op_expr(); _impl_.node_.op_expr_ = op_expr; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.op_expr) } inline ::pg_query::OpExpr* Node::_internal_mutable_op_expr() { if (!_internal_has_op_expr()) { clear_node(); set_has_op_expr(); _impl_.node_.op_expr_ = CreateMaybeMessage< ::pg_query::OpExpr >(GetArenaForAllocation()); } return _impl_.node_.op_expr_; } inline ::pg_query::OpExpr* Node::mutable_op_expr() { ::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 = 13 [json_name = "DistinctExpr"]; inline bool Node::_internal_has_distinct_expr() const { return node_case() == kDistinctExpr; } inline bool Node::has_distinct_expr() const { return _internal_has_distinct_expr(); } inline void Node::set_has_distinct_expr() { _impl_._oneof_case_[0] = kDistinctExpr; } inline void Node::clear_distinct_expr() { if (_internal_has_distinct_expr()) { if (GetArenaForAllocation() == 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 (_internal_has_distinct_expr()) { clear_has_node(); ::pg_query::DistinctExpr* temp = _impl_.node_.distinct_expr_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.distinct_expr_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::DistinctExpr& Node::_internal_distinct_expr() const { return _internal_has_distinct_expr() ? *_impl_.node_.distinct_expr_ : reinterpret_cast< ::pg_query::DistinctExpr&>(::pg_query::_DistinctExpr_default_instance_); } inline const ::pg_query::DistinctExpr& Node::distinct_expr() const { // @@protoc_insertion_point(field_get:pg_query.Node.distinct_expr) return _internal_distinct_expr(); } inline ::pg_query::DistinctExpr* Node::unsafe_arena_release_distinct_expr() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.distinct_expr) if (_internal_has_distinct_expr()) { clear_has_node(); ::pg_query::DistinctExpr* temp = _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* distinct_expr) { clear_node(); if (distinct_expr) { set_has_distinct_expr(); _impl_.node_.distinct_expr_ = distinct_expr; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.distinct_expr) } inline ::pg_query::DistinctExpr* Node::_internal_mutable_distinct_expr() { if (!_internal_has_distinct_expr()) { clear_node(); set_has_distinct_expr(); _impl_.node_.distinct_expr_ = CreateMaybeMessage< ::pg_query::DistinctExpr >(GetArenaForAllocation()); } return _impl_.node_.distinct_expr_; } inline ::pg_query::DistinctExpr* Node::mutable_distinct_expr() { ::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 = 14 [json_name = "NullIfExpr"]; inline bool Node::_internal_has_null_if_expr() const { return node_case() == kNullIfExpr; } inline bool Node::has_null_if_expr() const { return _internal_has_null_if_expr(); } inline void Node::set_has_null_if_expr() { _impl_._oneof_case_[0] = kNullIfExpr; } inline void Node::clear_null_if_expr() { if (_internal_has_null_if_expr()) { if (GetArenaForAllocation() == 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 (_internal_has_null_if_expr()) { clear_has_node(); ::pg_query::NullIfExpr* temp = _impl_.node_.null_if_expr_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_null_if_expr() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.null_if_expr) return _internal_null_if_expr(); } inline ::pg_query::NullIfExpr* Node::unsafe_arena_release_null_if_expr() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.null_if_expr) if (_internal_has_null_if_expr()) { clear_has_node(); ::pg_query::NullIfExpr* temp = _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* null_if_expr) { clear_node(); if (null_if_expr) { set_has_null_if_expr(); _impl_.node_.null_if_expr_ = null_if_expr; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.null_if_expr) } inline ::pg_query::NullIfExpr* Node::_internal_mutable_null_if_expr() { if (!_internal_has_null_if_expr()) { clear_node(); set_has_null_if_expr(); _impl_.node_.null_if_expr_ = CreateMaybeMessage< ::pg_query::NullIfExpr >(GetArenaForAllocation()); } return _impl_.node_.null_if_expr_; } inline ::pg_query::NullIfExpr* Node::mutable_null_if_expr() { ::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 = 15 [json_name = "ScalarArrayOpExpr"]; inline bool Node::_internal_has_scalar_array_op_expr() const { return node_case() == kScalarArrayOpExpr; } inline bool Node::has_scalar_array_op_expr() const { return _internal_has_scalar_array_op_expr(); } inline void Node::set_has_scalar_array_op_expr() { _impl_._oneof_case_[0] = kScalarArrayOpExpr; } inline void Node::clear_scalar_array_op_expr() { if (_internal_has_scalar_array_op_expr()) { if (GetArenaForAllocation() == 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 (_internal_has_scalar_array_op_expr()) { clear_has_node(); ::pg_query::ScalarArrayOpExpr* temp = _impl_.node_.scalar_array_op_expr_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_scalar_array_op_expr() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.scalar_array_op_expr) return _internal_scalar_array_op_expr(); } inline ::pg_query::ScalarArrayOpExpr* Node::unsafe_arena_release_scalar_array_op_expr() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.scalar_array_op_expr) if (_internal_has_scalar_array_op_expr()) { clear_has_node(); ::pg_query::ScalarArrayOpExpr* temp = _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* scalar_array_op_expr) { clear_node(); if (scalar_array_op_expr) { set_has_scalar_array_op_expr(); _impl_.node_.scalar_array_op_expr_ = scalar_array_op_expr; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.scalar_array_op_expr) } inline ::pg_query::ScalarArrayOpExpr* Node::_internal_mutable_scalar_array_op_expr() { if (!_internal_has_scalar_array_op_expr()) { clear_node(); set_has_scalar_array_op_expr(); _impl_.node_.scalar_array_op_expr_ = CreateMaybeMessage< ::pg_query::ScalarArrayOpExpr >(GetArenaForAllocation()); } return _impl_.node_.scalar_array_op_expr_; } inline ::pg_query::ScalarArrayOpExpr* Node::mutable_scalar_array_op_expr() { ::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 = 16 [json_name = "BoolExpr"]; inline bool Node::_internal_has_bool_expr() const { return node_case() == kBoolExpr; } inline bool Node::has_bool_expr() const { return _internal_has_bool_expr(); } inline void Node::set_has_bool_expr() { _impl_._oneof_case_[0] = kBoolExpr; } inline void Node::clear_bool_expr() { if (_internal_has_bool_expr()) { if (GetArenaForAllocation() == 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 (_internal_has_bool_expr()) { clear_has_node(); ::pg_query::BoolExpr* temp = _impl_.node_.bool_expr_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.bool_expr_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::BoolExpr& Node::_internal_bool_expr() const { return _internal_has_bool_expr() ? *_impl_.node_.bool_expr_ : reinterpret_cast< ::pg_query::BoolExpr&>(::pg_query::_BoolExpr_default_instance_); } inline const ::pg_query::BoolExpr& Node::bool_expr() const { // @@protoc_insertion_point(field_get:pg_query.Node.bool_expr) return _internal_bool_expr(); } inline ::pg_query::BoolExpr* Node::unsafe_arena_release_bool_expr() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.bool_expr) if (_internal_has_bool_expr()) { clear_has_node(); ::pg_query::BoolExpr* temp = _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* bool_expr) { clear_node(); if (bool_expr) { set_has_bool_expr(); _impl_.node_.bool_expr_ = bool_expr; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.bool_expr) } inline ::pg_query::BoolExpr* Node::_internal_mutable_bool_expr() { if (!_internal_has_bool_expr()) { clear_node(); set_has_bool_expr(); _impl_.node_.bool_expr_ = CreateMaybeMessage< ::pg_query::BoolExpr >(GetArenaForAllocation()); } return _impl_.node_.bool_expr_; } inline ::pg_query::BoolExpr* Node::mutable_bool_expr() { ::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 = 17 [json_name = "SubLink"]; inline bool Node::_internal_has_sub_link() const { return node_case() == kSubLink; } inline bool Node::has_sub_link() const { return _internal_has_sub_link(); } inline void Node::set_has_sub_link() { _impl_._oneof_case_[0] = kSubLink; } inline void Node::clear_sub_link() { if (_internal_has_sub_link()) { if (GetArenaForAllocation() == 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 (_internal_has_sub_link()) { clear_has_node(); ::pg_query::SubLink* temp = _impl_.node_.sub_link_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.sub_link_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::SubLink& Node::_internal_sub_link() const { return _internal_has_sub_link() ? *_impl_.node_.sub_link_ : reinterpret_cast< ::pg_query::SubLink&>(::pg_query::_SubLink_default_instance_); } inline const ::pg_query::SubLink& Node::sub_link() const { // @@protoc_insertion_point(field_get:pg_query.Node.sub_link) return _internal_sub_link(); } inline ::pg_query::SubLink* Node::unsafe_arena_release_sub_link() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.sub_link) if (_internal_has_sub_link()) { clear_has_node(); ::pg_query::SubLink* temp = _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* sub_link) { clear_node(); if (sub_link) { set_has_sub_link(); _impl_.node_.sub_link_ = sub_link; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.sub_link) } inline ::pg_query::SubLink* Node::_internal_mutable_sub_link() { if (!_internal_has_sub_link()) { clear_node(); set_has_sub_link(); _impl_.node_.sub_link_ = CreateMaybeMessage< ::pg_query::SubLink >(GetArenaForAllocation()); } return _impl_.node_.sub_link_; } inline ::pg_query::SubLink* Node::mutable_sub_link() { ::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 = 18 [json_name = "SubPlan"]; inline bool Node::_internal_has_sub_plan() const { return node_case() == kSubPlan; } inline bool Node::has_sub_plan() const { return _internal_has_sub_plan(); } inline void Node::set_has_sub_plan() { _impl_._oneof_case_[0] = kSubPlan; } inline void Node::clear_sub_plan() { if (_internal_has_sub_plan()) { if (GetArenaForAllocation() == 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 (_internal_has_sub_plan()) { clear_has_node(); ::pg_query::SubPlan* temp = _impl_.node_.sub_plan_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.sub_plan_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::SubPlan& Node::_internal_sub_plan() const { return _internal_has_sub_plan() ? *_impl_.node_.sub_plan_ : reinterpret_cast< ::pg_query::SubPlan&>(::pg_query::_SubPlan_default_instance_); } inline const ::pg_query::SubPlan& Node::sub_plan() const { // @@protoc_insertion_point(field_get:pg_query.Node.sub_plan) return _internal_sub_plan(); } inline ::pg_query::SubPlan* Node::unsafe_arena_release_sub_plan() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.sub_plan) if (_internal_has_sub_plan()) { clear_has_node(); ::pg_query::SubPlan* temp = _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* sub_plan) { clear_node(); if (sub_plan) { set_has_sub_plan(); _impl_.node_.sub_plan_ = sub_plan; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.sub_plan) } inline ::pg_query::SubPlan* Node::_internal_mutable_sub_plan() { if (!_internal_has_sub_plan()) { clear_node(); set_has_sub_plan(); _impl_.node_.sub_plan_ = CreateMaybeMessage< ::pg_query::SubPlan >(GetArenaForAllocation()); } return _impl_.node_.sub_plan_; } inline ::pg_query::SubPlan* Node::mutable_sub_plan() { ::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 = 19 [json_name = "AlternativeSubPlan"]; inline bool Node::_internal_has_alternative_sub_plan() const { return node_case() == kAlternativeSubPlan; } inline bool Node::has_alternative_sub_plan() const { return _internal_has_alternative_sub_plan(); } inline void Node::set_has_alternative_sub_plan() { _impl_._oneof_case_[0] = kAlternativeSubPlan; } inline void Node::clear_alternative_sub_plan() { if (_internal_has_alternative_sub_plan()) { if (GetArenaForAllocation() == 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 (_internal_has_alternative_sub_plan()) { clear_has_node(); ::pg_query::AlternativeSubPlan* temp = _impl_.node_.alternative_sub_plan_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alternative_sub_plan() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alternative_sub_plan) return _internal_alternative_sub_plan(); } inline ::pg_query::AlternativeSubPlan* Node::unsafe_arena_release_alternative_sub_plan() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alternative_sub_plan) if (_internal_has_alternative_sub_plan()) { clear_has_node(); ::pg_query::AlternativeSubPlan* temp = _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* alternative_sub_plan) { clear_node(); if (alternative_sub_plan) { set_has_alternative_sub_plan(); _impl_.node_.alternative_sub_plan_ = alternative_sub_plan; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alternative_sub_plan) } inline ::pg_query::AlternativeSubPlan* Node::_internal_mutable_alternative_sub_plan() { if (!_internal_has_alternative_sub_plan()) { clear_node(); set_has_alternative_sub_plan(); _impl_.node_.alternative_sub_plan_ = CreateMaybeMessage< ::pg_query::AlternativeSubPlan >(GetArenaForAllocation()); } return _impl_.node_.alternative_sub_plan_; } inline ::pg_query::AlternativeSubPlan* Node::mutable_alternative_sub_plan() { ::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 = 20 [json_name = "FieldSelect"]; inline bool Node::_internal_has_field_select() const { return node_case() == kFieldSelect; } inline bool Node::has_field_select() const { return _internal_has_field_select(); } inline void Node::set_has_field_select() { _impl_._oneof_case_[0] = kFieldSelect; } inline void Node::clear_field_select() { if (_internal_has_field_select()) { if (GetArenaForAllocation() == 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 (_internal_has_field_select()) { clear_has_node(); ::pg_query::FieldSelect* temp = _impl_.node_.field_select_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.field_select_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::FieldSelect& Node::_internal_field_select() const { return _internal_has_field_select() ? *_impl_.node_.field_select_ : reinterpret_cast< ::pg_query::FieldSelect&>(::pg_query::_FieldSelect_default_instance_); } inline const ::pg_query::FieldSelect& Node::field_select() const { // @@protoc_insertion_point(field_get:pg_query.Node.field_select) return _internal_field_select(); } inline ::pg_query::FieldSelect* Node::unsafe_arena_release_field_select() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.field_select) if (_internal_has_field_select()) { clear_has_node(); ::pg_query::FieldSelect* temp = _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* field_select) { clear_node(); if (field_select) { set_has_field_select(); _impl_.node_.field_select_ = field_select; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.field_select) } inline ::pg_query::FieldSelect* Node::_internal_mutable_field_select() { if (!_internal_has_field_select()) { clear_node(); set_has_field_select(); _impl_.node_.field_select_ = CreateMaybeMessage< ::pg_query::FieldSelect >(GetArenaForAllocation()); } return _impl_.node_.field_select_; } inline ::pg_query::FieldSelect* Node::mutable_field_select() { ::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 = 21 [json_name = "FieldStore"]; inline bool Node::_internal_has_field_store() const { return node_case() == kFieldStore; } inline bool Node::has_field_store() const { return _internal_has_field_store(); } inline void Node::set_has_field_store() { _impl_._oneof_case_[0] = kFieldStore; } inline void Node::clear_field_store() { if (_internal_has_field_store()) { if (GetArenaForAllocation() == 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 (_internal_has_field_store()) { clear_has_node(); ::pg_query::FieldStore* temp = _impl_.node_.field_store_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.field_store_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::FieldStore& Node::_internal_field_store() const { return _internal_has_field_store() ? *_impl_.node_.field_store_ : reinterpret_cast< ::pg_query::FieldStore&>(::pg_query::_FieldStore_default_instance_); } inline const ::pg_query::FieldStore& Node::field_store() const { // @@protoc_insertion_point(field_get:pg_query.Node.field_store) return _internal_field_store(); } inline ::pg_query::FieldStore* Node::unsafe_arena_release_field_store() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.field_store) if (_internal_has_field_store()) { clear_has_node(); ::pg_query::FieldStore* temp = _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* field_store) { clear_node(); if (field_store) { set_has_field_store(); _impl_.node_.field_store_ = field_store; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.field_store) } inline ::pg_query::FieldStore* Node::_internal_mutable_field_store() { if (!_internal_has_field_store()) { clear_node(); set_has_field_store(); _impl_.node_.field_store_ = CreateMaybeMessage< ::pg_query::FieldStore >(GetArenaForAllocation()); } return _impl_.node_.field_store_; } inline ::pg_query::FieldStore* Node::mutable_field_store() { ::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 = 22 [json_name = "RelabelType"]; inline bool Node::_internal_has_relabel_type() const { return node_case() == kRelabelType; } inline bool Node::has_relabel_type() const { return _internal_has_relabel_type(); } inline void Node::set_has_relabel_type() { _impl_._oneof_case_[0] = kRelabelType; } inline void Node::clear_relabel_type() { if (_internal_has_relabel_type()) { if (GetArenaForAllocation() == 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 (_internal_has_relabel_type()) { clear_has_node(); ::pg_query::RelabelType* temp = _impl_.node_.relabel_type_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.relabel_type_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::RelabelType& Node::_internal_relabel_type() const { return _internal_has_relabel_type() ? *_impl_.node_.relabel_type_ : reinterpret_cast< ::pg_query::RelabelType&>(::pg_query::_RelabelType_default_instance_); } inline const ::pg_query::RelabelType& Node::relabel_type() const { // @@protoc_insertion_point(field_get:pg_query.Node.relabel_type) return _internal_relabel_type(); } inline ::pg_query::RelabelType* Node::unsafe_arena_release_relabel_type() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.relabel_type) if (_internal_has_relabel_type()) { clear_has_node(); ::pg_query::RelabelType* temp = _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* relabel_type) { clear_node(); if (relabel_type) { set_has_relabel_type(); _impl_.node_.relabel_type_ = relabel_type; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.relabel_type) } inline ::pg_query::RelabelType* Node::_internal_mutable_relabel_type() { if (!_internal_has_relabel_type()) { clear_node(); set_has_relabel_type(); _impl_.node_.relabel_type_ = CreateMaybeMessage< ::pg_query::RelabelType >(GetArenaForAllocation()); } return _impl_.node_.relabel_type_; } inline ::pg_query::RelabelType* Node::mutable_relabel_type() { ::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 = 23 [json_name = "CoerceViaIO"]; inline bool Node::_internal_has_coerce_via_io() const { return node_case() == kCoerceViaIo; } inline bool Node::has_coerce_via_io() const { return _internal_has_coerce_via_io(); } inline void Node::set_has_coerce_via_io() { _impl_._oneof_case_[0] = kCoerceViaIo; } inline void Node::clear_coerce_via_io() { if (_internal_has_coerce_via_io()) { if (GetArenaForAllocation() == 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 (_internal_has_coerce_via_io()) { clear_has_node(); ::pg_query::CoerceViaIO* temp = _impl_.node_.coerce_via_io_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_coerce_via_io() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.coerce_via_io) return _internal_coerce_via_io(); } inline ::pg_query::CoerceViaIO* Node::unsafe_arena_release_coerce_via_io() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.coerce_via_io) if (_internal_has_coerce_via_io()) { clear_has_node(); ::pg_query::CoerceViaIO* temp = _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* coerce_via_io) { clear_node(); if (coerce_via_io) { set_has_coerce_via_io(); _impl_.node_.coerce_via_io_ = coerce_via_io; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.coerce_via_io) } inline ::pg_query::CoerceViaIO* Node::_internal_mutable_coerce_via_io() { if (!_internal_has_coerce_via_io()) { clear_node(); set_has_coerce_via_io(); _impl_.node_.coerce_via_io_ = CreateMaybeMessage< ::pg_query::CoerceViaIO >(GetArenaForAllocation()); } return _impl_.node_.coerce_via_io_; } inline ::pg_query::CoerceViaIO* Node::mutable_coerce_via_io() { ::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 = 24 [json_name = "ArrayCoerceExpr"]; inline bool Node::_internal_has_array_coerce_expr() const { return node_case() == kArrayCoerceExpr; } inline bool Node::has_array_coerce_expr() const { return _internal_has_array_coerce_expr(); } inline void Node::set_has_array_coerce_expr() { _impl_._oneof_case_[0] = kArrayCoerceExpr; } inline void Node::clear_array_coerce_expr() { if (_internal_has_array_coerce_expr()) { if (GetArenaForAllocation() == 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 (_internal_has_array_coerce_expr()) { clear_has_node(); ::pg_query::ArrayCoerceExpr* temp = _impl_.node_.array_coerce_expr_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_array_coerce_expr() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.array_coerce_expr) return _internal_array_coerce_expr(); } inline ::pg_query::ArrayCoerceExpr* Node::unsafe_arena_release_array_coerce_expr() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.array_coerce_expr) if (_internal_has_array_coerce_expr()) { clear_has_node(); ::pg_query::ArrayCoerceExpr* temp = _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* array_coerce_expr) { clear_node(); if (array_coerce_expr) { set_has_array_coerce_expr(); _impl_.node_.array_coerce_expr_ = array_coerce_expr; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.array_coerce_expr) } inline ::pg_query::ArrayCoerceExpr* Node::_internal_mutable_array_coerce_expr() { if (!_internal_has_array_coerce_expr()) { clear_node(); set_has_array_coerce_expr(); _impl_.node_.array_coerce_expr_ = CreateMaybeMessage< ::pg_query::ArrayCoerceExpr >(GetArenaForAllocation()); } return _impl_.node_.array_coerce_expr_; } inline ::pg_query::ArrayCoerceExpr* Node::mutable_array_coerce_expr() { ::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 = 25 [json_name = "ConvertRowtypeExpr"]; inline bool Node::_internal_has_convert_rowtype_expr() const { return node_case() == kConvertRowtypeExpr; } inline bool Node::has_convert_rowtype_expr() const { return _internal_has_convert_rowtype_expr(); } inline void Node::set_has_convert_rowtype_expr() { _impl_._oneof_case_[0] = kConvertRowtypeExpr; } inline void Node::clear_convert_rowtype_expr() { if (_internal_has_convert_rowtype_expr()) { if (GetArenaForAllocation() == 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 (_internal_has_convert_rowtype_expr()) { clear_has_node(); ::pg_query::ConvertRowtypeExpr* temp = _impl_.node_.convert_rowtype_expr_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_convert_rowtype_expr() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.convert_rowtype_expr) return _internal_convert_rowtype_expr(); } inline ::pg_query::ConvertRowtypeExpr* Node::unsafe_arena_release_convert_rowtype_expr() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.convert_rowtype_expr) if (_internal_has_convert_rowtype_expr()) { clear_has_node(); ::pg_query::ConvertRowtypeExpr* temp = _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* convert_rowtype_expr) { clear_node(); if (convert_rowtype_expr) { set_has_convert_rowtype_expr(); _impl_.node_.convert_rowtype_expr_ = convert_rowtype_expr; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.convert_rowtype_expr) } inline ::pg_query::ConvertRowtypeExpr* Node::_internal_mutable_convert_rowtype_expr() { if (!_internal_has_convert_rowtype_expr()) { clear_node(); set_has_convert_rowtype_expr(); _impl_.node_.convert_rowtype_expr_ = CreateMaybeMessage< ::pg_query::ConvertRowtypeExpr >(GetArenaForAllocation()); } return _impl_.node_.convert_rowtype_expr_; } inline ::pg_query::ConvertRowtypeExpr* Node::mutable_convert_rowtype_expr() { ::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 = 26 [json_name = "CollateExpr"]; inline bool Node::_internal_has_collate_expr() const { return node_case() == kCollateExpr; } inline bool Node::has_collate_expr() const { return _internal_has_collate_expr(); } inline void Node::set_has_collate_expr() { _impl_._oneof_case_[0] = kCollateExpr; } inline void Node::clear_collate_expr() { if (_internal_has_collate_expr()) { if (GetArenaForAllocation() == 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 (_internal_has_collate_expr()) { clear_has_node(); ::pg_query::CollateExpr* temp = _impl_.node_.collate_expr_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.collate_expr_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::CollateExpr& Node::_internal_collate_expr() const { return _internal_has_collate_expr() ? *_impl_.node_.collate_expr_ : reinterpret_cast< ::pg_query::CollateExpr&>(::pg_query::_CollateExpr_default_instance_); } inline const ::pg_query::CollateExpr& Node::collate_expr() const { // @@protoc_insertion_point(field_get:pg_query.Node.collate_expr) return _internal_collate_expr(); } inline ::pg_query::CollateExpr* Node::unsafe_arena_release_collate_expr() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.collate_expr) if (_internal_has_collate_expr()) { clear_has_node(); ::pg_query::CollateExpr* temp = _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* collate_expr) { clear_node(); if (collate_expr) { set_has_collate_expr(); _impl_.node_.collate_expr_ = collate_expr; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.collate_expr) } inline ::pg_query::CollateExpr* Node::_internal_mutable_collate_expr() { if (!_internal_has_collate_expr()) { clear_node(); set_has_collate_expr(); _impl_.node_.collate_expr_ = CreateMaybeMessage< ::pg_query::CollateExpr >(GetArenaForAllocation()); } return _impl_.node_.collate_expr_; } inline ::pg_query::CollateExpr* Node::mutable_collate_expr() { ::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 = 27 [json_name = "CaseExpr"]; inline bool Node::_internal_has_case_expr() const { return node_case() == kCaseExpr; } inline bool Node::has_case_expr() const { return _internal_has_case_expr(); } inline void Node::set_has_case_expr() { _impl_._oneof_case_[0] = kCaseExpr; } inline void Node::clear_case_expr() { if (_internal_has_case_expr()) { if (GetArenaForAllocation() == 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 (_internal_has_case_expr()) { clear_has_node(); ::pg_query::CaseExpr* temp = _impl_.node_.case_expr_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.case_expr_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::CaseExpr& Node::_internal_case_expr() const { return _internal_has_case_expr() ? *_impl_.node_.case_expr_ : reinterpret_cast< ::pg_query::CaseExpr&>(::pg_query::_CaseExpr_default_instance_); } inline const ::pg_query::CaseExpr& Node::case_expr() const { // @@protoc_insertion_point(field_get:pg_query.Node.case_expr) return _internal_case_expr(); } inline ::pg_query::CaseExpr* Node::unsafe_arena_release_case_expr() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.case_expr) if (_internal_has_case_expr()) { clear_has_node(); ::pg_query::CaseExpr* temp = _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* case_expr) { clear_node(); if (case_expr) { set_has_case_expr(); _impl_.node_.case_expr_ = case_expr; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.case_expr) } inline ::pg_query::CaseExpr* Node::_internal_mutable_case_expr() { if (!_internal_has_case_expr()) { clear_node(); set_has_case_expr(); _impl_.node_.case_expr_ = CreateMaybeMessage< ::pg_query::CaseExpr >(GetArenaForAllocation()); } return _impl_.node_.case_expr_; } inline ::pg_query::CaseExpr* Node::mutable_case_expr() { ::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 = 28 [json_name = "CaseWhen"]; inline bool Node::_internal_has_case_when() const { return node_case() == kCaseWhen; } inline bool Node::has_case_when() const { return _internal_has_case_when(); } inline void Node::set_has_case_when() { _impl_._oneof_case_[0] = kCaseWhen; } inline void Node::clear_case_when() { if (_internal_has_case_when()) { if (GetArenaForAllocation() == 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 (_internal_has_case_when()) { clear_has_node(); ::pg_query::CaseWhen* temp = _impl_.node_.case_when_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.case_when_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::CaseWhen& Node::_internal_case_when() const { return _internal_has_case_when() ? *_impl_.node_.case_when_ : reinterpret_cast< ::pg_query::CaseWhen&>(::pg_query::_CaseWhen_default_instance_); } inline const ::pg_query::CaseWhen& Node::case_when() const { // @@protoc_insertion_point(field_get:pg_query.Node.case_when) return _internal_case_when(); } inline ::pg_query::CaseWhen* Node::unsafe_arena_release_case_when() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.case_when) if (_internal_has_case_when()) { clear_has_node(); ::pg_query::CaseWhen* temp = _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* case_when) { clear_node(); if (case_when) { set_has_case_when(); _impl_.node_.case_when_ = case_when; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.case_when) } inline ::pg_query::CaseWhen* Node::_internal_mutable_case_when() { if (!_internal_has_case_when()) { clear_node(); set_has_case_when(); _impl_.node_.case_when_ = CreateMaybeMessage< ::pg_query::CaseWhen >(GetArenaForAllocation()); } return _impl_.node_.case_when_; } inline ::pg_query::CaseWhen* Node::mutable_case_when() { ::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 = 29 [json_name = "CaseTestExpr"]; inline bool Node::_internal_has_case_test_expr() const { return node_case() == kCaseTestExpr; } inline bool Node::has_case_test_expr() const { return _internal_has_case_test_expr(); } inline void Node::set_has_case_test_expr() { _impl_._oneof_case_[0] = kCaseTestExpr; } inline void Node::clear_case_test_expr() { if (_internal_has_case_test_expr()) { if (GetArenaForAllocation() == 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 (_internal_has_case_test_expr()) { clear_has_node(); ::pg_query::CaseTestExpr* temp = _impl_.node_.case_test_expr_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_case_test_expr() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.case_test_expr) return _internal_case_test_expr(); } inline ::pg_query::CaseTestExpr* Node::unsafe_arena_release_case_test_expr() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.case_test_expr) if (_internal_has_case_test_expr()) { clear_has_node(); ::pg_query::CaseTestExpr* temp = _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* case_test_expr) { clear_node(); if (case_test_expr) { set_has_case_test_expr(); _impl_.node_.case_test_expr_ = case_test_expr; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.case_test_expr) } inline ::pg_query::CaseTestExpr* Node::_internal_mutable_case_test_expr() { if (!_internal_has_case_test_expr()) { clear_node(); set_has_case_test_expr(); _impl_.node_.case_test_expr_ = CreateMaybeMessage< ::pg_query::CaseTestExpr >(GetArenaForAllocation()); } return _impl_.node_.case_test_expr_; } inline ::pg_query::CaseTestExpr* Node::mutable_case_test_expr() { ::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 = 30 [json_name = "ArrayExpr"]; inline bool Node::_internal_has_array_expr() const { return node_case() == kArrayExpr; } inline bool Node::has_array_expr() const { return _internal_has_array_expr(); } inline void Node::set_has_array_expr() { _impl_._oneof_case_[0] = kArrayExpr; } inline void Node::clear_array_expr() { if (_internal_has_array_expr()) { if (GetArenaForAllocation() == 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 (_internal_has_array_expr()) { clear_has_node(); ::pg_query::ArrayExpr* temp = _impl_.node_.array_expr_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.array_expr_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::ArrayExpr& Node::_internal_array_expr() const { return _internal_has_array_expr() ? *_impl_.node_.array_expr_ : reinterpret_cast< ::pg_query::ArrayExpr&>(::pg_query::_ArrayExpr_default_instance_); } inline const ::pg_query::ArrayExpr& Node::array_expr() const { // @@protoc_insertion_point(field_get:pg_query.Node.array_expr) return _internal_array_expr(); } inline ::pg_query::ArrayExpr* Node::unsafe_arena_release_array_expr() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.array_expr) if (_internal_has_array_expr()) { clear_has_node(); ::pg_query::ArrayExpr* temp = _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* array_expr) { clear_node(); if (array_expr) { set_has_array_expr(); _impl_.node_.array_expr_ = array_expr; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.array_expr) } inline ::pg_query::ArrayExpr* Node::_internal_mutable_array_expr() { if (!_internal_has_array_expr()) { clear_node(); set_has_array_expr(); _impl_.node_.array_expr_ = CreateMaybeMessage< ::pg_query::ArrayExpr >(GetArenaForAllocation()); } return _impl_.node_.array_expr_; } inline ::pg_query::ArrayExpr* Node::mutable_array_expr() { ::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 = 31 [json_name = "RowExpr"]; inline bool Node::_internal_has_row_expr() const { return node_case() == kRowExpr; } inline bool Node::has_row_expr() const { return _internal_has_row_expr(); } inline void Node::set_has_row_expr() { _impl_._oneof_case_[0] = kRowExpr; } inline void Node::clear_row_expr() { if (_internal_has_row_expr()) { if (GetArenaForAllocation() == 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 (_internal_has_row_expr()) { clear_has_node(); ::pg_query::RowExpr* temp = _impl_.node_.row_expr_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.row_expr_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::RowExpr& Node::_internal_row_expr() const { return _internal_has_row_expr() ? *_impl_.node_.row_expr_ : reinterpret_cast< ::pg_query::RowExpr&>(::pg_query::_RowExpr_default_instance_); } inline const ::pg_query::RowExpr& Node::row_expr() const { // @@protoc_insertion_point(field_get:pg_query.Node.row_expr) return _internal_row_expr(); } inline ::pg_query::RowExpr* Node::unsafe_arena_release_row_expr() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.row_expr) if (_internal_has_row_expr()) { clear_has_node(); ::pg_query::RowExpr* temp = _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* row_expr) { clear_node(); if (row_expr) { set_has_row_expr(); _impl_.node_.row_expr_ = row_expr; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.row_expr) } inline ::pg_query::RowExpr* Node::_internal_mutable_row_expr() { if (!_internal_has_row_expr()) { clear_node(); set_has_row_expr(); _impl_.node_.row_expr_ = CreateMaybeMessage< ::pg_query::RowExpr >(GetArenaForAllocation()); } return _impl_.node_.row_expr_; } inline ::pg_query::RowExpr* Node::mutable_row_expr() { ::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 = 32 [json_name = "RowCompareExpr"]; inline bool Node::_internal_has_row_compare_expr() const { return node_case() == kRowCompareExpr; } inline bool Node::has_row_compare_expr() const { return _internal_has_row_compare_expr(); } inline void Node::set_has_row_compare_expr() { _impl_._oneof_case_[0] = kRowCompareExpr; } inline void Node::clear_row_compare_expr() { if (_internal_has_row_compare_expr()) { if (GetArenaForAllocation() == 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 (_internal_has_row_compare_expr()) { clear_has_node(); ::pg_query::RowCompareExpr* temp = _impl_.node_.row_compare_expr_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_row_compare_expr() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.row_compare_expr) return _internal_row_compare_expr(); } inline ::pg_query::RowCompareExpr* Node::unsafe_arena_release_row_compare_expr() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.row_compare_expr) if (_internal_has_row_compare_expr()) { clear_has_node(); ::pg_query::RowCompareExpr* temp = _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* row_compare_expr) { clear_node(); if (row_compare_expr) { set_has_row_compare_expr(); _impl_.node_.row_compare_expr_ = row_compare_expr; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.row_compare_expr) } inline ::pg_query::RowCompareExpr* Node::_internal_mutable_row_compare_expr() { if (!_internal_has_row_compare_expr()) { clear_node(); set_has_row_compare_expr(); _impl_.node_.row_compare_expr_ = CreateMaybeMessage< ::pg_query::RowCompareExpr >(GetArenaForAllocation()); } return _impl_.node_.row_compare_expr_; } inline ::pg_query::RowCompareExpr* Node::mutable_row_compare_expr() { ::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 = 33 [json_name = "CoalesceExpr"]; inline bool Node::_internal_has_coalesce_expr() const { return node_case() == kCoalesceExpr; } inline bool Node::has_coalesce_expr() const { return _internal_has_coalesce_expr(); } inline void Node::set_has_coalesce_expr() { _impl_._oneof_case_[0] = kCoalesceExpr; } inline void Node::clear_coalesce_expr() { if (_internal_has_coalesce_expr()) { if (GetArenaForAllocation() == 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 (_internal_has_coalesce_expr()) { clear_has_node(); ::pg_query::CoalesceExpr* temp = _impl_.node_.coalesce_expr_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.coalesce_expr_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::CoalesceExpr& Node::_internal_coalesce_expr() const { return _internal_has_coalesce_expr() ? *_impl_.node_.coalesce_expr_ : reinterpret_cast< ::pg_query::CoalesceExpr&>(::pg_query::_CoalesceExpr_default_instance_); } inline const ::pg_query::CoalesceExpr& Node::coalesce_expr() const { // @@protoc_insertion_point(field_get:pg_query.Node.coalesce_expr) return _internal_coalesce_expr(); } inline ::pg_query::CoalesceExpr* Node::unsafe_arena_release_coalesce_expr() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.coalesce_expr) if (_internal_has_coalesce_expr()) { clear_has_node(); ::pg_query::CoalesceExpr* temp = _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* coalesce_expr) { clear_node(); if (coalesce_expr) { set_has_coalesce_expr(); _impl_.node_.coalesce_expr_ = coalesce_expr; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.coalesce_expr) } inline ::pg_query::CoalesceExpr* Node::_internal_mutable_coalesce_expr() { if (!_internal_has_coalesce_expr()) { clear_node(); set_has_coalesce_expr(); _impl_.node_.coalesce_expr_ = CreateMaybeMessage< ::pg_query::CoalesceExpr >(GetArenaForAllocation()); } return _impl_.node_.coalesce_expr_; } inline ::pg_query::CoalesceExpr* Node::mutable_coalesce_expr() { ::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 = 34 [json_name = "MinMaxExpr"]; inline bool Node::_internal_has_min_max_expr() const { return node_case() == kMinMaxExpr; } inline bool Node::has_min_max_expr() const { return _internal_has_min_max_expr(); } inline void Node::set_has_min_max_expr() { _impl_._oneof_case_[0] = kMinMaxExpr; } inline void Node::clear_min_max_expr() { if (_internal_has_min_max_expr()) { if (GetArenaForAllocation() == 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 (_internal_has_min_max_expr()) { clear_has_node(); ::pg_query::MinMaxExpr* temp = _impl_.node_.min_max_expr_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_min_max_expr() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.min_max_expr) return _internal_min_max_expr(); } inline ::pg_query::MinMaxExpr* Node::unsafe_arena_release_min_max_expr() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.min_max_expr) if (_internal_has_min_max_expr()) { clear_has_node(); ::pg_query::MinMaxExpr* temp = _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* min_max_expr) { clear_node(); if (min_max_expr) { set_has_min_max_expr(); _impl_.node_.min_max_expr_ = min_max_expr; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.min_max_expr) } inline ::pg_query::MinMaxExpr* Node::_internal_mutable_min_max_expr() { if (!_internal_has_min_max_expr()) { clear_node(); set_has_min_max_expr(); _impl_.node_.min_max_expr_ = CreateMaybeMessage< ::pg_query::MinMaxExpr >(GetArenaForAllocation()); } return _impl_.node_.min_max_expr_; } inline ::pg_query::MinMaxExpr* Node::mutable_min_max_expr() { ::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 = 35 [json_name = "SQLValueFunction"]; inline bool Node::_internal_has_sqlvalue_function() const { return node_case() == kSqlvalueFunction; } inline bool Node::has_sqlvalue_function() const { return _internal_has_sqlvalue_function(); } inline void Node::set_has_sqlvalue_function() { _impl_._oneof_case_[0] = kSqlvalueFunction; } inline void Node::clear_sqlvalue_function() { if (_internal_has_sqlvalue_function()) { if (GetArenaForAllocation() == 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 (_internal_has_sqlvalue_function()) { clear_has_node(); ::pg_query::SQLValueFunction* temp = _impl_.node_.sqlvalue_function_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.sqlvalue_function_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::SQLValueFunction& Node::_internal_sqlvalue_function() const { return _internal_has_sqlvalue_function() ? *_impl_.node_.sqlvalue_function_ : reinterpret_cast< ::pg_query::SQLValueFunction&>(::pg_query::_SQLValueFunction_default_instance_); } inline const ::pg_query::SQLValueFunction& Node::sqlvalue_function() const { // @@protoc_insertion_point(field_get:pg_query.Node.sqlvalue_function) return _internal_sqlvalue_function(); } inline ::pg_query::SQLValueFunction* Node::unsafe_arena_release_sqlvalue_function() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.sqlvalue_function) if (_internal_has_sqlvalue_function()) { clear_has_node(); ::pg_query::SQLValueFunction* temp = _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* sqlvalue_function) { clear_node(); if (sqlvalue_function) { set_has_sqlvalue_function(); _impl_.node_.sqlvalue_function_ = sqlvalue_function; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.sqlvalue_function) } inline ::pg_query::SQLValueFunction* Node::_internal_mutable_sqlvalue_function() { if (!_internal_has_sqlvalue_function()) { clear_node(); set_has_sqlvalue_function(); _impl_.node_.sqlvalue_function_ = CreateMaybeMessage< ::pg_query::SQLValueFunction >(GetArenaForAllocation()); } return _impl_.node_.sqlvalue_function_; } inline ::pg_query::SQLValueFunction* Node::mutable_sqlvalue_function() { ::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 = 36 [json_name = "XmlExpr"]; inline bool Node::_internal_has_xml_expr() const { return node_case() == kXmlExpr; } inline bool Node::has_xml_expr() const { return _internal_has_xml_expr(); } inline void Node::set_has_xml_expr() { _impl_._oneof_case_[0] = kXmlExpr; } inline void Node::clear_xml_expr() { if (_internal_has_xml_expr()) { if (GetArenaForAllocation() == 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 (_internal_has_xml_expr()) { clear_has_node(); ::pg_query::XmlExpr* temp = _impl_.node_.xml_expr_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.xml_expr_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::XmlExpr& Node::_internal_xml_expr() const { return _internal_has_xml_expr() ? *_impl_.node_.xml_expr_ : reinterpret_cast< ::pg_query::XmlExpr&>(::pg_query::_XmlExpr_default_instance_); } inline const ::pg_query::XmlExpr& Node::xml_expr() const { // @@protoc_insertion_point(field_get:pg_query.Node.xml_expr) return _internal_xml_expr(); } inline ::pg_query::XmlExpr* Node::unsafe_arena_release_xml_expr() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.xml_expr) if (_internal_has_xml_expr()) { clear_has_node(); ::pg_query::XmlExpr* temp = _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* xml_expr) { clear_node(); if (xml_expr) { set_has_xml_expr(); _impl_.node_.xml_expr_ = xml_expr; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.xml_expr) } inline ::pg_query::XmlExpr* Node::_internal_mutable_xml_expr() { if (!_internal_has_xml_expr()) { clear_node(); set_has_xml_expr(); _impl_.node_.xml_expr_ = CreateMaybeMessage< ::pg_query::XmlExpr >(GetArenaForAllocation()); } return _impl_.node_.xml_expr_; } inline ::pg_query::XmlExpr* Node::mutable_xml_expr() { ::pg_query::XmlExpr* _msg = _internal_mutable_xml_expr(); // @@protoc_insertion_point(field_mutable:pg_query.Node.xml_expr) return _msg; } // .pg_query.NullTest null_test = 37 [json_name = "NullTest"]; inline bool Node::_internal_has_null_test() const { return node_case() == kNullTest; } inline bool Node::has_null_test() const { return _internal_has_null_test(); } inline void Node::set_has_null_test() { _impl_._oneof_case_[0] = kNullTest; } inline void Node::clear_null_test() { if (_internal_has_null_test()) { if (GetArenaForAllocation() == 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 (_internal_has_null_test()) { clear_has_node(); ::pg_query::NullTest* temp = _impl_.node_.null_test_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.null_test_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::NullTest& Node::_internal_null_test() const { return _internal_has_null_test() ? *_impl_.node_.null_test_ : reinterpret_cast< ::pg_query::NullTest&>(::pg_query::_NullTest_default_instance_); } inline const ::pg_query::NullTest& Node::null_test() const { // @@protoc_insertion_point(field_get:pg_query.Node.null_test) return _internal_null_test(); } inline ::pg_query::NullTest* Node::unsafe_arena_release_null_test() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.null_test) if (_internal_has_null_test()) { clear_has_node(); ::pg_query::NullTest* temp = _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* null_test) { clear_node(); if (null_test) { set_has_null_test(); _impl_.node_.null_test_ = null_test; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.null_test) } inline ::pg_query::NullTest* Node::_internal_mutable_null_test() { if (!_internal_has_null_test()) { clear_node(); set_has_null_test(); _impl_.node_.null_test_ = CreateMaybeMessage< ::pg_query::NullTest >(GetArenaForAllocation()); } return _impl_.node_.null_test_; } inline ::pg_query::NullTest* Node::mutable_null_test() { ::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 = 38 [json_name = "BooleanTest"]; inline bool Node::_internal_has_boolean_test() const { return node_case() == kBooleanTest; } inline bool Node::has_boolean_test() const { return _internal_has_boolean_test(); } inline void Node::set_has_boolean_test() { _impl_._oneof_case_[0] = kBooleanTest; } inline void Node::clear_boolean_test() { if (_internal_has_boolean_test()) { if (GetArenaForAllocation() == 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 (_internal_has_boolean_test()) { clear_has_node(); ::pg_query::BooleanTest* temp = _impl_.node_.boolean_test_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.boolean_test_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::BooleanTest& Node::_internal_boolean_test() const { return _internal_has_boolean_test() ? *_impl_.node_.boolean_test_ : reinterpret_cast< ::pg_query::BooleanTest&>(::pg_query::_BooleanTest_default_instance_); } inline const ::pg_query::BooleanTest& Node::boolean_test() const { // @@protoc_insertion_point(field_get:pg_query.Node.boolean_test) return _internal_boolean_test(); } inline ::pg_query::BooleanTest* Node::unsafe_arena_release_boolean_test() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.boolean_test) if (_internal_has_boolean_test()) { clear_has_node(); ::pg_query::BooleanTest* temp = _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* boolean_test) { clear_node(); if (boolean_test) { set_has_boolean_test(); _impl_.node_.boolean_test_ = boolean_test; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.boolean_test) } inline ::pg_query::BooleanTest* Node::_internal_mutable_boolean_test() { if (!_internal_has_boolean_test()) { clear_node(); set_has_boolean_test(); _impl_.node_.boolean_test_ = CreateMaybeMessage< ::pg_query::BooleanTest >(GetArenaForAllocation()); } return _impl_.node_.boolean_test_; } inline ::pg_query::BooleanTest* Node::mutable_boolean_test() { ::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 = 39 [json_name = "CoerceToDomain"]; inline bool Node::_internal_has_coerce_to_domain() const { return node_case() == kCoerceToDomain; } inline bool Node::has_coerce_to_domain() const { return _internal_has_coerce_to_domain(); } inline void Node::set_has_coerce_to_domain() { _impl_._oneof_case_[0] = kCoerceToDomain; } inline void Node::clear_coerce_to_domain() { if (_internal_has_coerce_to_domain()) { if (GetArenaForAllocation() == 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 (_internal_has_coerce_to_domain()) { clear_has_node(); ::pg_query::CoerceToDomain* temp = _impl_.node_.coerce_to_domain_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_coerce_to_domain() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.coerce_to_domain) return _internal_coerce_to_domain(); } inline ::pg_query::CoerceToDomain* Node::unsafe_arena_release_coerce_to_domain() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.coerce_to_domain) if (_internal_has_coerce_to_domain()) { clear_has_node(); ::pg_query::CoerceToDomain* temp = _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* coerce_to_domain) { clear_node(); if (coerce_to_domain) { set_has_coerce_to_domain(); _impl_.node_.coerce_to_domain_ = coerce_to_domain; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.coerce_to_domain) } inline ::pg_query::CoerceToDomain* Node::_internal_mutable_coerce_to_domain() { if (!_internal_has_coerce_to_domain()) { clear_node(); set_has_coerce_to_domain(); _impl_.node_.coerce_to_domain_ = CreateMaybeMessage< ::pg_query::CoerceToDomain >(GetArenaForAllocation()); } return _impl_.node_.coerce_to_domain_; } inline ::pg_query::CoerceToDomain* Node::mutable_coerce_to_domain() { ::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 = 40 [json_name = "CoerceToDomainValue"]; inline bool Node::_internal_has_coerce_to_domain_value() const { return node_case() == kCoerceToDomainValue; } inline bool Node::has_coerce_to_domain_value() const { return _internal_has_coerce_to_domain_value(); } inline void Node::set_has_coerce_to_domain_value() { _impl_._oneof_case_[0] = kCoerceToDomainValue; } inline void Node::clear_coerce_to_domain_value() { if (_internal_has_coerce_to_domain_value()) { if (GetArenaForAllocation() == 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 (_internal_has_coerce_to_domain_value()) { clear_has_node(); ::pg_query::CoerceToDomainValue* temp = _impl_.node_.coerce_to_domain_value_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_coerce_to_domain_value() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.coerce_to_domain_value) return _internal_coerce_to_domain_value(); } inline ::pg_query::CoerceToDomainValue* Node::unsafe_arena_release_coerce_to_domain_value() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.coerce_to_domain_value) if (_internal_has_coerce_to_domain_value()) { clear_has_node(); ::pg_query::CoerceToDomainValue* temp = _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* coerce_to_domain_value) { clear_node(); if (coerce_to_domain_value) { set_has_coerce_to_domain_value(); _impl_.node_.coerce_to_domain_value_ = coerce_to_domain_value; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.coerce_to_domain_value) } inline ::pg_query::CoerceToDomainValue* Node::_internal_mutable_coerce_to_domain_value() { if (!_internal_has_coerce_to_domain_value()) { clear_node(); set_has_coerce_to_domain_value(); _impl_.node_.coerce_to_domain_value_ = CreateMaybeMessage< ::pg_query::CoerceToDomainValue >(GetArenaForAllocation()); } return _impl_.node_.coerce_to_domain_value_; } inline ::pg_query::CoerceToDomainValue* Node::mutable_coerce_to_domain_value() { ::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 = 41 [json_name = "SetToDefault"]; inline bool Node::_internal_has_set_to_default() const { return node_case() == kSetToDefault; } inline bool Node::has_set_to_default() const { return _internal_has_set_to_default(); } inline void Node::set_has_set_to_default() { _impl_._oneof_case_[0] = kSetToDefault; } inline void Node::clear_set_to_default() { if (_internal_has_set_to_default()) { if (GetArenaForAllocation() == 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 (_internal_has_set_to_default()) { clear_has_node(); ::pg_query::SetToDefault* temp = _impl_.node_.set_to_default_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_set_to_default() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.set_to_default) return _internal_set_to_default(); } inline ::pg_query::SetToDefault* Node::unsafe_arena_release_set_to_default() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.set_to_default) if (_internal_has_set_to_default()) { clear_has_node(); ::pg_query::SetToDefault* temp = _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* set_to_default) { clear_node(); if (set_to_default) { set_has_set_to_default(); _impl_.node_.set_to_default_ = set_to_default; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.set_to_default) } inline ::pg_query::SetToDefault* Node::_internal_mutable_set_to_default() { if (!_internal_has_set_to_default()) { clear_node(); set_has_set_to_default(); _impl_.node_.set_to_default_ = CreateMaybeMessage< ::pg_query::SetToDefault >(GetArenaForAllocation()); } return _impl_.node_.set_to_default_; } inline ::pg_query::SetToDefault* Node::mutable_set_to_default() { ::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 = 42 [json_name = "CurrentOfExpr"]; inline bool Node::_internal_has_current_of_expr() const { return node_case() == kCurrentOfExpr; } inline bool Node::has_current_of_expr() const { return _internal_has_current_of_expr(); } inline void Node::set_has_current_of_expr() { _impl_._oneof_case_[0] = kCurrentOfExpr; } inline void Node::clear_current_of_expr() { if (_internal_has_current_of_expr()) { if (GetArenaForAllocation() == 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 (_internal_has_current_of_expr()) { clear_has_node(); ::pg_query::CurrentOfExpr* temp = _impl_.node_.current_of_expr_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_current_of_expr() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.current_of_expr) return _internal_current_of_expr(); } inline ::pg_query::CurrentOfExpr* Node::unsafe_arena_release_current_of_expr() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.current_of_expr) if (_internal_has_current_of_expr()) { clear_has_node(); ::pg_query::CurrentOfExpr* temp = _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* current_of_expr) { clear_node(); if (current_of_expr) { set_has_current_of_expr(); _impl_.node_.current_of_expr_ = current_of_expr; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.current_of_expr) } inline ::pg_query::CurrentOfExpr* Node::_internal_mutable_current_of_expr() { if (!_internal_has_current_of_expr()) { clear_node(); set_has_current_of_expr(); _impl_.node_.current_of_expr_ = CreateMaybeMessage< ::pg_query::CurrentOfExpr >(GetArenaForAllocation()); } return _impl_.node_.current_of_expr_; } inline ::pg_query::CurrentOfExpr* Node::mutable_current_of_expr() { ::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 = 43 [json_name = "NextValueExpr"]; inline bool Node::_internal_has_next_value_expr() const { return node_case() == kNextValueExpr; } inline bool Node::has_next_value_expr() const { return _internal_has_next_value_expr(); } inline void Node::set_has_next_value_expr() { _impl_._oneof_case_[0] = kNextValueExpr; } inline void Node::clear_next_value_expr() { if (_internal_has_next_value_expr()) { if (GetArenaForAllocation() == 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 (_internal_has_next_value_expr()) { clear_has_node(); ::pg_query::NextValueExpr* temp = _impl_.node_.next_value_expr_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_next_value_expr() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.next_value_expr) return _internal_next_value_expr(); } inline ::pg_query::NextValueExpr* Node::unsafe_arena_release_next_value_expr() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.next_value_expr) if (_internal_has_next_value_expr()) { clear_has_node(); ::pg_query::NextValueExpr* temp = _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* next_value_expr) { clear_node(); if (next_value_expr) { set_has_next_value_expr(); _impl_.node_.next_value_expr_ = next_value_expr; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.next_value_expr) } inline ::pg_query::NextValueExpr* Node::_internal_mutable_next_value_expr() { if (!_internal_has_next_value_expr()) { clear_node(); set_has_next_value_expr(); _impl_.node_.next_value_expr_ = CreateMaybeMessage< ::pg_query::NextValueExpr >(GetArenaForAllocation()); } return _impl_.node_.next_value_expr_; } inline ::pg_query::NextValueExpr* Node::mutable_next_value_expr() { ::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 = 44 [json_name = "InferenceElem"]; inline bool Node::_internal_has_inference_elem() const { return node_case() == kInferenceElem; } inline bool Node::has_inference_elem() const { return _internal_has_inference_elem(); } inline void Node::set_has_inference_elem() { _impl_._oneof_case_[0] = kInferenceElem; } inline void Node::clear_inference_elem() { if (_internal_has_inference_elem()) { if (GetArenaForAllocation() == 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 (_internal_has_inference_elem()) { clear_has_node(); ::pg_query::InferenceElem* temp = _impl_.node_.inference_elem_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.inference_elem_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::InferenceElem& Node::_internal_inference_elem() const { return _internal_has_inference_elem() ? *_impl_.node_.inference_elem_ : reinterpret_cast< ::pg_query::InferenceElem&>(::pg_query::_InferenceElem_default_instance_); } inline const ::pg_query::InferenceElem& Node::inference_elem() const { // @@protoc_insertion_point(field_get:pg_query.Node.inference_elem) return _internal_inference_elem(); } inline ::pg_query::InferenceElem* Node::unsafe_arena_release_inference_elem() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.inference_elem) if (_internal_has_inference_elem()) { clear_has_node(); ::pg_query::InferenceElem* temp = _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* inference_elem) { clear_node(); if (inference_elem) { set_has_inference_elem(); _impl_.node_.inference_elem_ = inference_elem; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.inference_elem) } inline ::pg_query::InferenceElem* Node::_internal_mutable_inference_elem() { if (!_internal_has_inference_elem()) { clear_node(); set_has_inference_elem(); _impl_.node_.inference_elem_ = CreateMaybeMessage< ::pg_query::InferenceElem >(GetArenaForAllocation()); } return _impl_.node_.inference_elem_; } inline ::pg_query::InferenceElem* Node::mutable_inference_elem() { ::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 = 45 [json_name = "TargetEntry"]; inline bool Node::_internal_has_target_entry() const { return node_case() == kTargetEntry; } inline bool Node::has_target_entry() const { return _internal_has_target_entry(); } inline void Node::set_has_target_entry() { _impl_._oneof_case_[0] = kTargetEntry; } inline void Node::clear_target_entry() { if (_internal_has_target_entry()) { if (GetArenaForAllocation() == 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 (_internal_has_target_entry()) { clear_has_node(); ::pg_query::TargetEntry* temp = _impl_.node_.target_entry_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.target_entry_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::TargetEntry& Node::_internal_target_entry() const { return _internal_has_target_entry() ? *_impl_.node_.target_entry_ : reinterpret_cast< ::pg_query::TargetEntry&>(::pg_query::_TargetEntry_default_instance_); } inline const ::pg_query::TargetEntry& Node::target_entry() const { // @@protoc_insertion_point(field_get:pg_query.Node.target_entry) return _internal_target_entry(); } inline ::pg_query::TargetEntry* Node::unsafe_arena_release_target_entry() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.target_entry) if (_internal_has_target_entry()) { clear_has_node(); ::pg_query::TargetEntry* temp = _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* target_entry) { clear_node(); if (target_entry) { set_has_target_entry(); _impl_.node_.target_entry_ = target_entry; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.target_entry) } inline ::pg_query::TargetEntry* Node::_internal_mutable_target_entry() { if (!_internal_has_target_entry()) { clear_node(); set_has_target_entry(); _impl_.node_.target_entry_ = CreateMaybeMessage< ::pg_query::TargetEntry >(GetArenaForAllocation()); } return _impl_.node_.target_entry_; } inline ::pg_query::TargetEntry* Node::mutable_target_entry() { ::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 = 46 [json_name = "RangeTblRef"]; inline bool Node::_internal_has_range_tbl_ref() const { return node_case() == kRangeTblRef; } inline bool Node::has_range_tbl_ref() const { return _internal_has_range_tbl_ref(); } inline void Node::set_has_range_tbl_ref() { _impl_._oneof_case_[0] = kRangeTblRef; } inline void Node::clear_range_tbl_ref() { if (_internal_has_range_tbl_ref()) { if (GetArenaForAllocation() == 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 (_internal_has_range_tbl_ref()) { clear_has_node(); ::pg_query::RangeTblRef* temp = _impl_.node_.range_tbl_ref_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_range_tbl_ref() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.range_tbl_ref) return _internal_range_tbl_ref(); } inline ::pg_query::RangeTblRef* Node::unsafe_arena_release_range_tbl_ref() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.range_tbl_ref) if (_internal_has_range_tbl_ref()) { clear_has_node(); ::pg_query::RangeTblRef* temp = _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* range_tbl_ref) { clear_node(); if (range_tbl_ref) { set_has_range_tbl_ref(); _impl_.node_.range_tbl_ref_ = range_tbl_ref; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.range_tbl_ref) } inline ::pg_query::RangeTblRef* Node::_internal_mutable_range_tbl_ref() { if (!_internal_has_range_tbl_ref()) { clear_node(); set_has_range_tbl_ref(); _impl_.node_.range_tbl_ref_ = CreateMaybeMessage< ::pg_query::RangeTblRef >(GetArenaForAllocation()); } return _impl_.node_.range_tbl_ref_; } inline ::pg_query::RangeTblRef* Node::mutable_range_tbl_ref() { ::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 = 47 [json_name = "JoinExpr"]; inline bool Node::_internal_has_join_expr() const { return node_case() == kJoinExpr; } inline bool Node::has_join_expr() const { return _internal_has_join_expr(); } inline void Node::set_has_join_expr() { _impl_._oneof_case_[0] = kJoinExpr; } inline void Node::clear_join_expr() { if (_internal_has_join_expr()) { if (GetArenaForAllocation() == 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 (_internal_has_join_expr()) { clear_has_node(); ::pg_query::JoinExpr* temp = _impl_.node_.join_expr_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.join_expr_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::JoinExpr& Node::_internal_join_expr() const { return _internal_has_join_expr() ? *_impl_.node_.join_expr_ : reinterpret_cast< ::pg_query::JoinExpr&>(::pg_query::_JoinExpr_default_instance_); } inline const ::pg_query::JoinExpr& Node::join_expr() const { // @@protoc_insertion_point(field_get:pg_query.Node.join_expr) return _internal_join_expr(); } inline ::pg_query::JoinExpr* Node::unsafe_arena_release_join_expr() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.join_expr) if (_internal_has_join_expr()) { clear_has_node(); ::pg_query::JoinExpr* temp = _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* join_expr) { clear_node(); if (join_expr) { set_has_join_expr(); _impl_.node_.join_expr_ = join_expr; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.join_expr) } inline ::pg_query::JoinExpr* Node::_internal_mutable_join_expr() { if (!_internal_has_join_expr()) { clear_node(); set_has_join_expr(); _impl_.node_.join_expr_ = CreateMaybeMessage< ::pg_query::JoinExpr >(GetArenaForAllocation()); } return _impl_.node_.join_expr_; } inline ::pg_query::JoinExpr* Node::mutable_join_expr() { ::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 = 48 [json_name = "FromExpr"]; inline bool Node::_internal_has_from_expr() const { return node_case() == kFromExpr; } inline bool Node::has_from_expr() const { return _internal_has_from_expr(); } inline void Node::set_has_from_expr() { _impl_._oneof_case_[0] = kFromExpr; } inline void Node::clear_from_expr() { if (_internal_has_from_expr()) { if (GetArenaForAllocation() == 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 (_internal_has_from_expr()) { clear_has_node(); ::pg_query::FromExpr* temp = _impl_.node_.from_expr_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.from_expr_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::FromExpr& Node::_internal_from_expr() const { return _internal_has_from_expr() ? *_impl_.node_.from_expr_ : reinterpret_cast< ::pg_query::FromExpr&>(::pg_query::_FromExpr_default_instance_); } inline const ::pg_query::FromExpr& Node::from_expr() const { // @@protoc_insertion_point(field_get:pg_query.Node.from_expr) return _internal_from_expr(); } inline ::pg_query::FromExpr* Node::unsafe_arena_release_from_expr() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.from_expr) if (_internal_has_from_expr()) { clear_has_node(); ::pg_query::FromExpr* temp = _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* from_expr) { clear_node(); if (from_expr) { set_has_from_expr(); _impl_.node_.from_expr_ = from_expr; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.from_expr) } inline ::pg_query::FromExpr* Node::_internal_mutable_from_expr() { if (!_internal_has_from_expr()) { clear_node(); set_has_from_expr(); _impl_.node_.from_expr_ = CreateMaybeMessage< ::pg_query::FromExpr >(GetArenaForAllocation()); } return _impl_.node_.from_expr_; } inline ::pg_query::FromExpr* Node::mutable_from_expr() { ::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 = 49 [json_name = "OnConflictExpr"]; inline bool Node::_internal_has_on_conflict_expr() const { return node_case() == kOnConflictExpr; } inline bool Node::has_on_conflict_expr() const { return _internal_has_on_conflict_expr(); } inline void Node::set_has_on_conflict_expr() { _impl_._oneof_case_[0] = kOnConflictExpr; } inline void Node::clear_on_conflict_expr() { if (_internal_has_on_conflict_expr()) { if (GetArenaForAllocation() == 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 (_internal_has_on_conflict_expr()) { clear_has_node(); ::pg_query::OnConflictExpr* temp = _impl_.node_.on_conflict_expr_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_on_conflict_expr() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.on_conflict_expr) return _internal_on_conflict_expr(); } inline ::pg_query::OnConflictExpr* Node::unsafe_arena_release_on_conflict_expr() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.on_conflict_expr) if (_internal_has_on_conflict_expr()) { clear_has_node(); ::pg_query::OnConflictExpr* temp = _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* on_conflict_expr) { clear_node(); if (on_conflict_expr) { set_has_on_conflict_expr(); _impl_.node_.on_conflict_expr_ = on_conflict_expr; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.on_conflict_expr) } inline ::pg_query::OnConflictExpr* Node::_internal_mutable_on_conflict_expr() { if (!_internal_has_on_conflict_expr()) { clear_node(); set_has_on_conflict_expr(); _impl_.node_.on_conflict_expr_ = CreateMaybeMessage< ::pg_query::OnConflictExpr >(GetArenaForAllocation()); } return _impl_.node_.on_conflict_expr_; } inline ::pg_query::OnConflictExpr* Node::mutable_on_conflict_expr() { ::pg_query::OnConflictExpr* _msg = _internal_mutable_on_conflict_expr(); // @@protoc_insertion_point(field_mutable:pg_query.Node.on_conflict_expr) return _msg; } // .pg_query.IntoClause into_clause = 50 [json_name = "IntoClause"]; inline bool Node::_internal_has_into_clause() const { return node_case() == kIntoClause; } inline bool Node::has_into_clause() const { return _internal_has_into_clause(); } inline void Node::set_has_into_clause() { _impl_._oneof_case_[0] = kIntoClause; } inline void Node::clear_into_clause() { if (_internal_has_into_clause()) { if (GetArenaForAllocation() == 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 (_internal_has_into_clause()) { clear_has_node(); ::pg_query::IntoClause* temp = _impl_.node_.into_clause_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.into_clause_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::IntoClause& Node::_internal_into_clause() const { return _internal_has_into_clause() ? *_impl_.node_.into_clause_ : reinterpret_cast< ::pg_query::IntoClause&>(::pg_query::_IntoClause_default_instance_); } inline const ::pg_query::IntoClause& Node::into_clause() const { // @@protoc_insertion_point(field_get:pg_query.Node.into_clause) return _internal_into_clause(); } inline ::pg_query::IntoClause* Node::unsafe_arena_release_into_clause() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.into_clause) if (_internal_has_into_clause()) { clear_has_node(); ::pg_query::IntoClause* temp = _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* into_clause) { clear_node(); if (into_clause) { set_has_into_clause(); _impl_.node_.into_clause_ = into_clause; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.into_clause) } inline ::pg_query::IntoClause* Node::_internal_mutable_into_clause() { if (!_internal_has_into_clause()) { clear_node(); set_has_into_clause(); _impl_.node_.into_clause_ = CreateMaybeMessage< ::pg_query::IntoClause >(GetArenaForAllocation()); } return _impl_.node_.into_clause_; } inline ::pg_query::IntoClause* Node::mutable_into_clause() { ::pg_query::IntoClause* _msg = _internal_mutable_into_clause(); // @@protoc_insertion_point(field_mutable:pg_query.Node.into_clause) return _msg; } // .pg_query.MergeAction merge_action = 51 [json_name = "MergeAction"]; inline bool Node::_internal_has_merge_action() const { return node_case() == kMergeAction; } inline bool Node::has_merge_action() const { return _internal_has_merge_action(); } inline void Node::set_has_merge_action() { _impl_._oneof_case_[0] = kMergeAction; } inline void Node::clear_merge_action() { if (_internal_has_merge_action()) { if (GetArenaForAllocation() == 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 (_internal_has_merge_action()) { clear_has_node(); ::pg_query::MergeAction* temp = _impl_.node_.merge_action_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.merge_action_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::MergeAction& Node::_internal_merge_action() const { return _internal_has_merge_action() ? *_impl_.node_.merge_action_ : reinterpret_cast< ::pg_query::MergeAction&>(::pg_query::_MergeAction_default_instance_); } inline const ::pg_query::MergeAction& Node::merge_action() const { // @@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 (_internal_has_merge_action()) { clear_has_node(); ::pg_query::MergeAction* 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* merge_action) { clear_node(); if (merge_action) { set_has_merge_action(); _impl_.node_.merge_action_ = merge_action; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.merge_action) } inline ::pg_query::MergeAction* Node::_internal_mutable_merge_action() { if (!_internal_has_merge_action()) { clear_node(); set_has_merge_action(); _impl_.node_.merge_action_ = CreateMaybeMessage< ::pg_query::MergeAction >(GetArenaForAllocation()); } return _impl_.node_.merge_action_; } inline ::pg_query::MergeAction* Node::mutable_merge_action() { ::pg_query::MergeAction* _msg = _internal_mutable_merge_action(); // @@protoc_insertion_point(field_mutable:pg_query.Node.merge_action) return _msg; } // .pg_query.RawStmt raw_stmt = 52 [json_name = "RawStmt"]; inline bool Node::_internal_has_raw_stmt() const { return node_case() == kRawStmt; } inline bool Node::has_raw_stmt() const { return _internal_has_raw_stmt(); } inline void Node::set_has_raw_stmt() { _impl_._oneof_case_[0] = kRawStmt; } inline void Node::clear_raw_stmt() { if (_internal_has_raw_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_raw_stmt()) { clear_has_node(); ::pg_query::RawStmt* temp = _impl_.node_.raw_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.raw_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::RawStmt& Node::_internal_raw_stmt() const { return _internal_has_raw_stmt() ? *_impl_.node_.raw_stmt_ : reinterpret_cast< ::pg_query::RawStmt&>(::pg_query::_RawStmt_default_instance_); } inline const ::pg_query::RawStmt& Node::raw_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.raw_stmt) return _internal_raw_stmt(); } inline ::pg_query::RawStmt* Node::unsafe_arena_release_raw_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.raw_stmt) if (_internal_has_raw_stmt()) { clear_has_node(); ::pg_query::RawStmt* temp = _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* raw_stmt) { clear_node(); if (raw_stmt) { set_has_raw_stmt(); _impl_.node_.raw_stmt_ = raw_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.raw_stmt) } inline ::pg_query::RawStmt* Node::_internal_mutable_raw_stmt() { if (!_internal_has_raw_stmt()) { clear_node(); set_has_raw_stmt(); _impl_.node_.raw_stmt_ = CreateMaybeMessage< ::pg_query::RawStmt >(GetArenaForAllocation()); } return _impl_.node_.raw_stmt_; } inline ::pg_query::RawStmt* Node::mutable_raw_stmt() { ::pg_query::RawStmt* _msg = _internal_mutable_raw_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.raw_stmt) return _msg; } // .pg_query.Query query = 53 [json_name = "Query"]; inline bool Node::_internal_has_query() const { return node_case() == kQuery; } inline bool Node::has_query() const { return _internal_has_query(); } inline void Node::set_has_query() { _impl_._oneof_case_[0] = kQuery; } inline void Node::clear_query() { if (_internal_has_query()) { if (GetArenaForAllocation() == 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 (_internal_has_query()) { clear_has_node(); ::pg_query::Query* temp = _impl_.node_.query_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.query_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::Query& Node::_internal_query() const { return _internal_has_query() ? *_impl_.node_.query_ : reinterpret_cast< ::pg_query::Query&>(::pg_query::_Query_default_instance_); } inline const ::pg_query::Query& Node::query() const { // @@protoc_insertion_point(field_get:pg_query.Node.query) return _internal_query(); } inline ::pg_query::Query* Node::unsafe_arena_release_query() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.query) if (_internal_has_query()) { clear_has_node(); ::pg_query::Query* temp = _impl_.node_.query_; _impl_.node_.query_ = nullptr; return temp; } else { return nullptr; } } inline void Node::unsafe_arena_set_allocated_query(::pg_query::Query* query) { clear_node(); if (query) { set_has_query(); _impl_.node_.query_ = query; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.query) } inline ::pg_query::Query* Node::_internal_mutable_query() { if (!_internal_has_query()) { clear_node(); set_has_query(); _impl_.node_.query_ = CreateMaybeMessage< ::pg_query::Query >(GetArenaForAllocation()); } return _impl_.node_.query_; } inline ::pg_query::Query* Node::mutable_query() { ::pg_query::Query* _msg = _internal_mutable_query(); // @@protoc_insertion_point(field_mutable:pg_query.Node.query) return _msg; } // .pg_query.InsertStmt insert_stmt = 54 [json_name = "InsertStmt"]; inline bool Node::_internal_has_insert_stmt() const { return node_case() == kInsertStmt; } inline bool Node::has_insert_stmt() const { return _internal_has_insert_stmt(); } inline void Node::set_has_insert_stmt() { _impl_._oneof_case_[0] = kInsertStmt; } inline void Node::clear_insert_stmt() { if (_internal_has_insert_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_insert_stmt()) { clear_has_node(); ::pg_query::InsertStmt* temp = _impl_.node_.insert_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.insert_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::InsertStmt& Node::_internal_insert_stmt() const { return _internal_has_insert_stmt() ? *_impl_.node_.insert_stmt_ : reinterpret_cast< ::pg_query::InsertStmt&>(::pg_query::_InsertStmt_default_instance_); } inline const ::pg_query::InsertStmt& Node::insert_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.insert_stmt) return _internal_insert_stmt(); } inline ::pg_query::InsertStmt* Node::unsafe_arena_release_insert_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.insert_stmt) if (_internal_has_insert_stmt()) { clear_has_node(); ::pg_query::InsertStmt* temp = _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* insert_stmt) { clear_node(); if (insert_stmt) { set_has_insert_stmt(); _impl_.node_.insert_stmt_ = insert_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.insert_stmt) } inline ::pg_query::InsertStmt* Node::_internal_mutable_insert_stmt() { if (!_internal_has_insert_stmt()) { clear_node(); set_has_insert_stmt(); _impl_.node_.insert_stmt_ = CreateMaybeMessage< ::pg_query::InsertStmt >(GetArenaForAllocation()); } return _impl_.node_.insert_stmt_; } inline ::pg_query::InsertStmt* Node::mutable_insert_stmt() { ::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 = 55 [json_name = "DeleteStmt"]; inline bool Node::_internal_has_delete_stmt() const { return node_case() == kDeleteStmt; } inline bool Node::has_delete_stmt() const { return _internal_has_delete_stmt(); } inline void Node::set_has_delete_stmt() { _impl_._oneof_case_[0] = kDeleteStmt; } inline void Node::clear_delete_stmt() { if (_internal_has_delete_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_delete_stmt()) { clear_has_node(); ::pg_query::DeleteStmt* temp = _impl_.node_.delete_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.delete_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::DeleteStmt& Node::_internal_delete_stmt() const { return _internal_has_delete_stmt() ? *_impl_.node_.delete_stmt_ : reinterpret_cast< ::pg_query::DeleteStmt&>(::pg_query::_DeleteStmt_default_instance_); } inline const ::pg_query::DeleteStmt& Node::delete_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.delete_stmt) return _internal_delete_stmt(); } inline ::pg_query::DeleteStmt* Node::unsafe_arena_release_delete_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.delete_stmt) if (_internal_has_delete_stmt()) { clear_has_node(); ::pg_query::DeleteStmt* temp = _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* delete_stmt) { clear_node(); if (delete_stmt) { set_has_delete_stmt(); _impl_.node_.delete_stmt_ = delete_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.delete_stmt) } inline ::pg_query::DeleteStmt* Node::_internal_mutable_delete_stmt() { if (!_internal_has_delete_stmt()) { clear_node(); set_has_delete_stmt(); _impl_.node_.delete_stmt_ = CreateMaybeMessage< ::pg_query::DeleteStmt >(GetArenaForAllocation()); } return _impl_.node_.delete_stmt_; } inline ::pg_query::DeleteStmt* Node::mutable_delete_stmt() { ::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 = 56 [json_name = "UpdateStmt"]; inline bool Node::_internal_has_update_stmt() const { return node_case() == kUpdateStmt; } inline bool Node::has_update_stmt() const { return _internal_has_update_stmt(); } inline void Node::set_has_update_stmt() { _impl_._oneof_case_[0] = kUpdateStmt; } inline void Node::clear_update_stmt() { if (_internal_has_update_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_update_stmt()) { clear_has_node(); ::pg_query::UpdateStmt* temp = _impl_.node_.update_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.update_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::UpdateStmt& Node::_internal_update_stmt() const { return _internal_has_update_stmt() ? *_impl_.node_.update_stmt_ : reinterpret_cast< ::pg_query::UpdateStmt&>(::pg_query::_UpdateStmt_default_instance_); } inline const ::pg_query::UpdateStmt& Node::update_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.update_stmt) return _internal_update_stmt(); } inline ::pg_query::UpdateStmt* Node::unsafe_arena_release_update_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.update_stmt) if (_internal_has_update_stmt()) { clear_has_node(); ::pg_query::UpdateStmt* temp = _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* update_stmt) { clear_node(); if (update_stmt) { set_has_update_stmt(); _impl_.node_.update_stmt_ = update_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.update_stmt) } inline ::pg_query::UpdateStmt* Node::_internal_mutable_update_stmt() { if (!_internal_has_update_stmt()) { clear_node(); set_has_update_stmt(); _impl_.node_.update_stmt_ = CreateMaybeMessage< ::pg_query::UpdateStmt >(GetArenaForAllocation()); } return _impl_.node_.update_stmt_; } inline ::pg_query::UpdateStmt* Node::mutable_update_stmt() { ::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 = 57 [json_name = "MergeStmt"]; inline bool Node::_internal_has_merge_stmt() const { return node_case() == kMergeStmt; } inline bool Node::has_merge_stmt() const { return _internal_has_merge_stmt(); } inline void Node::set_has_merge_stmt() { _impl_._oneof_case_[0] = kMergeStmt; } inline void Node::clear_merge_stmt() { if (_internal_has_merge_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_merge_stmt()) { clear_has_node(); ::pg_query::MergeStmt* temp = _impl_.node_.merge_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.merge_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::MergeStmt& Node::_internal_merge_stmt() const { return _internal_has_merge_stmt() ? *_impl_.node_.merge_stmt_ : reinterpret_cast< ::pg_query::MergeStmt&>(::pg_query::_MergeStmt_default_instance_); } inline const ::pg_query::MergeStmt& Node::merge_stmt() const { // @@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 (_internal_has_merge_stmt()) { clear_has_node(); ::pg_query::MergeStmt* 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* merge_stmt) { clear_node(); if (merge_stmt) { set_has_merge_stmt(); _impl_.node_.merge_stmt_ = merge_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.merge_stmt) } inline ::pg_query::MergeStmt* Node::_internal_mutable_merge_stmt() { if (!_internal_has_merge_stmt()) { clear_node(); set_has_merge_stmt(); _impl_.node_.merge_stmt_ = CreateMaybeMessage< ::pg_query::MergeStmt >(GetArenaForAllocation()); } return _impl_.node_.merge_stmt_; } inline ::pg_query::MergeStmt* Node::mutable_merge_stmt() { ::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 = 58 [json_name = "SelectStmt"]; inline bool Node::_internal_has_select_stmt() const { return node_case() == kSelectStmt; } inline bool Node::has_select_stmt() const { return _internal_has_select_stmt(); } inline void Node::set_has_select_stmt() { _impl_._oneof_case_[0] = kSelectStmt; } inline void Node::clear_select_stmt() { if (_internal_has_select_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_select_stmt()) { clear_has_node(); ::pg_query::SelectStmt* temp = _impl_.node_.select_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.select_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::SelectStmt& Node::_internal_select_stmt() const { return _internal_has_select_stmt() ? *_impl_.node_.select_stmt_ : reinterpret_cast< ::pg_query::SelectStmt&>(::pg_query::_SelectStmt_default_instance_); } inline const ::pg_query::SelectStmt& Node::select_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.select_stmt) return _internal_select_stmt(); } inline ::pg_query::SelectStmt* Node::unsafe_arena_release_select_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.select_stmt) if (_internal_has_select_stmt()) { clear_has_node(); ::pg_query::SelectStmt* temp = _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* select_stmt) { clear_node(); if (select_stmt) { set_has_select_stmt(); _impl_.node_.select_stmt_ = select_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.select_stmt) } inline ::pg_query::SelectStmt* Node::_internal_mutable_select_stmt() { if (!_internal_has_select_stmt()) { clear_node(); set_has_select_stmt(); _impl_.node_.select_stmt_ = CreateMaybeMessage< ::pg_query::SelectStmt >(GetArenaForAllocation()); } return _impl_.node_.select_stmt_; } inline ::pg_query::SelectStmt* Node::mutable_select_stmt() { ::pg_query::SelectStmt* _msg = _internal_mutable_select_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.select_stmt) return _msg; } // .pg_query.ReturnStmt return_stmt = 59 [json_name = "ReturnStmt"]; inline bool Node::_internal_has_return_stmt() const { return node_case() == kReturnStmt; } inline bool Node::has_return_stmt() const { return _internal_has_return_stmt(); } inline void Node::set_has_return_stmt() { _impl_._oneof_case_[0] = kReturnStmt; } inline void Node::clear_return_stmt() { if (_internal_has_return_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_return_stmt()) { clear_has_node(); ::pg_query::ReturnStmt* temp = _impl_.node_.return_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.return_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::ReturnStmt& Node::_internal_return_stmt() const { return _internal_has_return_stmt() ? *_impl_.node_.return_stmt_ : reinterpret_cast< ::pg_query::ReturnStmt&>(::pg_query::_ReturnStmt_default_instance_); } inline const ::pg_query::ReturnStmt& Node::return_stmt() const { // @@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 (_internal_has_return_stmt()) { clear_has_node(); ::pg_query::ReturnStmt* 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* return_stmt) { clear_node(); if (return_stmt) { set_has_return_stmt(); _impl_.node_.return_stmt_ = return_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.return_stmt) } inline ::pg_query::ReturnStmt* Node::_internal_mutable_return_stmt() { if (!_internal_has_return_stmt()) { clear_node(); set_has_return_stmt(); _impl_.node_.return_stmt_ = CreateMaybeMessage< ::pg_query::ReturnStmt >(GetArenaForAllocation()); } return _impl_.node_.return_stmt_; } inline ::pg_query::ReturnStmt* Node::mutable_return_stmt() { ::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 = 60 [json_name = "PLAssignStmt"]; inline bool Node::_internal_has_plassign_stmt() const { return node_case() == kPlassignStmt; } inline bool Node::has_plassign_stmt() const { return _internal_has_plassign_stmt(); } inline void Node::set_has_plassign_stmt() { _impl_._oneof_case_[0] = kPlassignStmt; } inline void Node::clear_plassign_stmt() { if (_internal_has_plassign_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_plassign_stmt()) { clear_has_node(); ::pg_query::PLAssignStmt* temp = _impl_.node_.plassign_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.plassign_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::PLAssignStmt& Node::_internal_plassign_stmt() const { return _internal_has_plassign_stmt() ? *_impl_.node_.plassign_stmt_ : reinterpret_cast< ::pg_query::PLAssignStmt&>(::pg_query::_PLAssignStmt_default_instance_); } inline const ::pg_query::PLAssignStmt& Node::plassign_stmt() const { // @@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 (_internal_has_plassign_stmt()) { clear_has_node(); ::pg_query::PLAssignStmt* 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* plassign_stmt) { clear_node(); if (plassign_stmt) { set_has_plassign_stmt(); _impl_.node_.plassign_stmt_ = plassign_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.plassign_stmt) } inline ::pg_query::PLAssignStmt* Node::_internal_mutable_plassign_stmt() { if (!_internal_has_plassign_stmt()) { clear_node(); set_has_plassign_stmt(); _impl_.node_.plassign_stmt_ = CreateMaybeMessage< ::pg_query::PLAssignStmt >(GetArenaForAllocation()); } return _impl_.node_.plassign_stmt_; } inline ::pg_query::PLAssignStmt* Node::mutable_plassign_stmt() { ::pg_query::PLAssignStmt* _msg = _internal_mutable_plassign_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.plassign_stmt) return _msg; } // .pg_query.AlterTableStmt alter_table_stmt = 61 [json_name = "AlterTableStmt"]; inline bool Node::_internal_has_alter_table_stmt() const { return node_case() == kAlterTableStmt; } inline bool Node::has_alter_table_stmt() const { return _internal_has_alter_table_stmt(); } inline void Node::set_has_alter_table_stmt() { _impl_._oneof_case_[0] = kAlterTableStmt; } inline void Node::clear_alter_table_stmt() { if (_internal_has_alter_table_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_table_stmt()) { clear_has_node(); ::pg_query::AlterTableStmt* temp = _impl_.node_.alter_table_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_table_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_table_stmt) return _internal_alter_table_stmt(); } inline ::pg_query::AlterTableStmt* Node::unsafe_arena_release_alter_table_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_table_stmt) if (_internal_has_alter_table_stmt()) { clear_has_node(); ::pg_query::AlterTableStmt* temp = _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* alter_table_stmt) { clear_node(); if (alter_table_stmt) { set_has_alter_table_stmt(); _impl_.node_.alter_table_stmt_ = alter_table_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_table_stmt) } inline ::pg_query::AlterTableStmt* Node::_internal_mutable_alter_table_stmt() { if (!_internal_has_alter_table_stmt()) { clear_node(); set_has_alter_table_stmt(); _impl_.node_.alter_table_stmt_ = CreateMaybeMessage< ::pg_query::AlterTableStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_table_stmt_; } inline ::pg_query::AlterTableStmt* Node::mutable_alter_table_stmt() { ::pg_query::AlterTableStmt* _msg = _internal_mutable_alter_table_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_table_stmt) return _msg; } // .pg_query.AlterTableCmd alter_table_cmd = 62 [json_name = "AlterTableCmd"]; inline bool Node::_internal_has_alter_table_cmd() const { return node_case() == kAlterTableCmd; } inline bool Node::has_alter_table_cmd() const { return _internal_has_alter_table_cmd(); } inline void Node::set_has_alter_table_cmd() { _impl_._oneof_case_[0] = kAlterTableCmd; } inline void Node::clear_alter_table_cmd() { if (_internal_has_alter_table_cmd()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_table_cmd()) { clear_has_node(); ::pg_query::AlterTableCmd* temp = _impl_.node_.alter_table_cmd_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_table_cmd() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_table_cmd) return _internal_alter_table_cmd(); } inline ::pg_query::AlterTableCmd* Node::unsafe_arena_release_alter_table_cmd() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_table_cmd) if (_internal_has_alter_table_cmd()) { clear_has_node(); ::pg_query::AlterTableCmd* temp = _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* alter_table_cmd) { clear_node(); if (alter_table_cmd) { set_has_alter_table_cmd(); _impl_.node_.alter_table_cmd_ = alter_table_cmd; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_table_cmd) } inline ::pg_query::AlterTableCmd* Node::_internal_mutable_alter_table_cmd() { if (!_internal_has_alter_table_cmd()) { clear_node(); set_has_alter_table_cmd(); _impl_.node_.alter_table_cmd_ = CreateMaybeMessage< ::pg_query::AlterTableCmd >(GetArenaForAllocation()); } return _impl_.node_.alter_table_cmd_; } inline ::pg_query::AlterTableCmd* Node::mutable_alter_table_cmd() { ::pg_query::AlterTableCmd* _msg = _internal_mutable_alter_table_cmd(); // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_table_cmd) return _msg; } // .pg_query.AlterDomainStmt alter_domain_stmt = 63 [json_name = "AlterDomainStmt"]; inline bool Node::_internal_has_alter_domain_stmt() const { return node_case() == kAlterDomainStmt; } inline bool Node::has_alter_domain_stmt() const { return _internal_has_alter_domain_stmt(); } inline void Node::set_has_alter_domain_stmt() { _impl_._oneof_case_[0] = kAlterDomainStmt; } inline void Node::clear_alter_domain_stmt() { if (_internal_has_alter_domain_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_domain_stmt()) { clear_has_node(); ::pg_query::AlterDomainStmt* temp = _impl_.node_.alter_domain_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_domain_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_domain_stmt) return _internal_alter_domain_stmt(); } inline ::pg_query::AlterDomainStmt* Node::unsafe_arena_release_alter_domain_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_domain_stmt) if (_internal_has_alter_domain_stmt()) { clear_has_node(); ::pg_query::AlterDomainStmt* temp = _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* alter_domain_stmt) { clear_node(); if (alter_domain_stmt) { set_has_alter_domain_stmt(); _impl_.node_.alter_domain_stmt_ = alter_domain_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_domain_stmt) } inline ::pg_query::AlterDomainStmt* Node::_internal_mutable_alter_domain_stmt() { if (!_internal_has_alter_domain_stmt()) { clear_node(); set_has_alter_domain_stmt(); _impl_.node_.alter_domain_stmt_ = CreateMaybeMessage< ::pg_query::AlterDomainStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_domain_stmt_; } inline ::pg_query::AlterDomainStmt* Node::mutable_alter_domain_stmt() { ::pg_query::AlterDomainStmt* _msg = _internal_mutable_alter_domain_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_domain_stmt) return _msg; } // .pg_query.SetOperationStmt set_operation_stmt = 64 [json_name = "SetOperationStmt"]; inline bool Node::_internal_has_set_operation_stmt() const { return node_case() == kSetOperationStmt; } inline bool Node::has_set_operation_stmt() const { return _internal_has_set_operation_stmt(); } inline void Node::set_has_set_operation_stmt() { _impl_._oneof_case_[0] = kSetOperationStmt; } inline void Node::clear_set_operation_stmt() { if (_internal_has_set_operation_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_set_operation_stmt()) { clear_has_node(); ::pg_query::SetOperationStmt* temp = _impl_.node_.set_operation_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_set_operation_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.set_operation_stmt) return _internal_set_operation_stmt(); } inline ::pg_query::SetOperationStmt* Node::unsafe_arena_release_set_operation_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.set_operation_stmt) if (_internal_has_set_operation_stmt()) { clear_has_node(); ::pg_query::SetOperationStmt* temp = _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* set_operation_stmt) { clear_node(); if (set_operation_stmt) { set_has_set_operation_stmt(); _impl_.node_.set_operation_stmt_ = set_operation_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.set_operation_stmt) } inline ::pg_query::SetOperationStmt* Node::_internal_mutable_set_operation_stmt() { if (!_internal_has_set_operation_stmt()) { clear_node(); set_has_set_operation_stmt(); _impl_.node_.set_operation_stmt_ = CreateMaybeMessage< ::pg_query::SetOperationStmt >(GetArenaForAllocation()); } return _impl_.node_.set_operation_stmt_; } inline ::pg_query::SetOperationStmt* Node::mutable_set_operation_stmt() { ::pg_query::SetOperationStmt* _msg = _internal_mutable_set_operation_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.set_operation_stmt) return _msg; } // .pg_query.GrantStmt grant_stmt = 65 [json_name = "GrantStmt"]; inline bool Node::_internal_has_grant_stmt() const { return node_case() == kGrantStmt; } inline bool Node::has_grant_stmt() const { return _internal_has_grant_stmt(); } inline void Node::set_has_grant_stmt() { _impl_._oneof_case_[0] = kGrantStmt; } inline void Node::clear_grant_stmt() { if (_internal_has_grant_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_grant_stmt()) { clear_has_node(); ::pg_query::GrantStmt* temp = _impl_.node_.grant_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.grant_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::GrantStmt& Node::_internal_grant_stmt() const { return _internal_has_grant_stmt() ? *_impl_.node_.grant_stmt_ : reinterpret_cast< ::pg_query::GrantStmt&>(::pg_query::_GrantStmt_default_instance_); } inline const ::pg_query::GrantStmt& Node::grant_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.grant_stmt) return _internal_grant_stmt(); } inline ::pg_query::GrantStmt* Node::unsafe_arena_release_grant_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.grant_stmt) if (_internal_has_grant_stmt()) { clear_has_node(); ::pg_query::GrantStmt* temp = _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* grant_stmt) { clear_node(); if (grant_stmt) { set_has_grant_stmt(); _impl_.node_.grant_stmt_ = grant_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.grant_stmt) } inline ::pg_query::GrantStmt* Node::_internal_mutable_grant_stmt() { if (!_internal_has_grant_stmt()) { clear_node(); set_has_grant_stmt(); _impl_.node_.grant_stmt_ = CreateMaybeMessage< ::pg_query::GrantStmt >(GetArenaForAllocation()); } return _impl_.node_.grant_stmt_; } inline ::pg_query::GrantStmt* Node::mutable_grant_stmt() { ::pg_query::GrantStmt* _msg = _internal_mutable_grant_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.grant_stmt) return _msg; } // .pg_query.GrantRoleStmt grant_role_stmt = 66 [json_name = "GrantRoleStmt"]; inline bool Node::_internal_has_grant_role_stmt() const { return node_case() == kGrantRoleStmt; } inline bool Node::has_grant_role_stmt() const { return _internal_has_grant_role_stmt(); } inline void Node::set_has_grant_role_stmt() { _impl_._oneof_case_[0] = kGrantRoleStmt; } inline void Node::clear_grant_role_stmt() { if (_internal_has_grant_role_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_grant_role_stmt()) { clear_has_node(); ::pg_query::GrantRoleStmt* temp = _impl_.node_.grant_role_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_grant_role_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.grant_role_stmt) return _internal_grant_role_stmt(); } inline ::pg_query::GrantRoleStmt* Node::unsafe_arena_release_grant_role_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.grant_role_stmt) if (_internal_has_grant_role_stmt()) { clear_has_node(); ::pg_query::GrantRoleStmt* temp = _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* grant_role_stmt) { clear_node(); if (grant_role_stmt) { set_has_grant_role_stmt(); _impl_.node_.grant_role_stmt_ = grant_role_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.grant_role_stmt) } inline ::pg_query::GrantRoleStmt* Node::_internal_mutable_grant_role_stmt() { if (!_internal_has_grant_role_stmt()) { clear_node(); set_has_grant_role_stmt(); _impl_.node_.grant_role_stmt_ = CreateMaybeMessage< ::pg_query::GrantRoleStmt >(GetArenaForAllocation()); } return _impl_.node_.grant_role_stmt_; } inline ::pg_query::GrantRoleStmt* Node::mutable_grant_role_stmt() { ::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 = 67 [json_name = "AlterDefaultPrivilegesStmt"]; inline bool Node::_internal_has_alter_default_privileges_stmt() const { return node_case() == kAlterDefaultPrivilegesStmt; } inline bool Node::has_alter_default_privileges_stmt() const { return _internal_has_alter_default_privileges_stmt(); } inline void Node::set_has_alter_default_privileges_stmt() { _impl_._oneof_case_[0] = kAlterDefaultPrivilegesStmt; } inline void Node::clear_alter_default_privileges_stmt() { if (_internal_has_alter_default_privileges_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_default_privileges_stmt()) { clear_has_node(); ::pg_query::AlterDefaultPrivilegesStmt* temp = _impl_.node_.alter_default_privileges_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_default_privileges_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_default_privileges_stmt) return _internal_alter_default_privileges_stmt(); } inline ::pg_query::AlterDefaultPrivilegesStmt* Node::unsafe_arena_release_alter_default_privileges_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_default_privileges_stmt) if (_internal_has_alter_default_privileges_stmt()) { clear_has_node(); ::pg_query::AlterDefaultPrivilegesStmt* temp = _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* alter_default_privileges_stmt) { clear_node(); if (alter_default_privileges_stmt) { set_has_alter_default_privileges_stmt(); _impl_.node_.alter_default_privileges_stmt_ = alter_default_privileges_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_default_privileges_stmt) } inline ::pg_query::AlterDefaultPrivilegesStmt* Node::_internal_mutable_alter_default_privileges_stmt() { if (!_internal_has_alter_default_privileges_stmt()) { clear_node(); set_has_alter_default_privileges_stmt(); _impl_.node_.alter_default_privileges_stmt_ = CreateMaybeMessage< ::pg_query::AlterDefaultPrivilegesStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_default_privileges_stmt_; } inline ::pg_query::AlterDefaultPrivilegesStmt* Node::mutable_alter_default_privileges_stmt() { ::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.ClosePortalStmt close_portal_stmt = 68 [json_name = "ClosePortalStmt"]; inline bool Node::_internal_has_close_portal_stmt() const { return node_case() == kClosePortalStmt; } inline bool Node::has_close_portal_stmt() const { return _internal_has_close_portal_stmt(); } inline void Node::set_has_close_portal_stmt() { _impl_._oneof_case_[0] = kClosePortalStmt; } inline void Node::clear_close_portal_stmt() { if (_internal_has_close_portal_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_close_portal_stmt()) { clear_has_node(); ::pg_query::ClosePortalStmt* temp = _impl_.node_.close_portal_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_close_portal_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.close_portal_stmt) return _internal_close_portal_stmt(); } inline ::pg_query::ClosePortalStmt* Node::unsafe_arena_release_close_portal_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.close_portal_stmt) if (_internal_has_close_portal_stmt()) { clear_has_node(); ::pg_query::ClosePortalStmt* temp = _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* close_portal_stmt) { clear_node(); if (close_portal_stmt) { set_has_close_portal_stmt(); _impl_.node_.close_portal_stmt_ = close_portal_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.close_portal_stmt) } inline ::pg_query::ClosePortalStmt* Node::_internal_mutable_close_portal_stmt() { if (!_internal_has_close_portal_stmt()) { clear_node(); set_has_close_portal_stmt(); _impl_.node_.close_portal_stmt_ = CreateMaybeMessage< ::pg_query::ClosePortalStmt >(GetArenaForAllocation()); } return _impl_.node_.close_portal_stmt_; } inline ::pg_query::ClosePortalStmt* Node::mutable_close_portal_stmt() { ::pg_query::ClosePortalStmt* _msg = _internal_mutable_close_portal_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.close_portal_stmt) return _msg; } // .pg_query.ClusterStmt cluster_stmt = 69 [json_name = "ClusterStmt"]; inline bool Node::_internal_has_cluster_stmt() const { return node_case() == kClusterStmt; } inline bool Node::has_cluster_stmt() const { return _internal_has_cluster_stmt(); } inline void Node::set_has_cluster_stmt() { _impl_._oneof_case_[0] = kClusterStmt; } inline void Node::clear_cluster_stmt() { if (_internal_has_cluster_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_cluster_stmt()) { clear_has_node(); ::pg_query::ClusterStmt* temp = _impl_.node_.cluster_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.cluster_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::ClusterStmt& Node::_internal_cluster_stmt() const { return _internal_has_cluster_stmt() ? *_impl_.node_.cluster_stmt_ : reinterpret_cast< ::pg_query::ClusterStmt&>(::pg_query::_ClusterStmt_default_instance_); } inline const ::pg_query::ClusterStmt& Node::cluster_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.cluster_stmt) return _internal_cluster_stmt(); } inline ::pg_query::ClusterStmt* Node::unsafe_arena_release_cluster_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.cluster_stmt) if (_internal_has_cluster_stmt()) { clear_has_node(); ::pg_query::ClusterStmt* temp = _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* cluster_stmt) { clear_node(); if (cluster_stmt) { set_has_cluster_stmt(); _impl_.node_.cluster_stmt_ = cluster_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.cluster_stmt) } inline ::pg_query::ClusterStmt* Node::_internal_mutable_cluster_stmt() { if (!_internal_has_cluster_stmt()) { clear_node(); set_has_cluster_stmt(); _impl_.node_.cluster_stmt_ = CreateMaybeMessage< ::pg_query::ClusterStmt >(GetArenaForAllocation()); } return _impl_.node_.cluster_stmt_; } inline ::pg_query::ClusterStmt* Node::mutable_cluster_stmt() { ::pg_query::ClusterStmt* _msg = _internal_mutable_cluster_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.cluster_stmt) return _msg; } // .pg_query.CopyStmt copy_stmt = 70 [json_name = "CopyStmt"]; inline bool Node::_internal_has_copy_stmt() const { return node_case() == kCopyStmt; } inline bool Node::has_copy_stmt() const { return _internal_has_copy_stmt(); } inline void Node::set_has_copy_stmt() { _impl_._oneof_case_[0] = kCopyStmt; } inline void Node::clear_copy_stmt() { if (_internal_has_copy_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_copy_stmt()) { clear_has_node(); ::pg_query::CopyStmt* temp = _impl_.node_.copy_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.copy_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::CopyStmt& Node::_internal_copy_stmt() const { return _internal_has_copy_stmt() ? *_impl_.node_.copy_stmt_ : reinterpret_cast< ::pg_query::CopyStmt&>(::pg_query::_CopyStmt_default_instance_); } inline const ::pg_query::CopyStmt& Node::copy_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.copy_stmt) return _internal_copy_stmt(); } inline ::pg_query::CopyStmt* Node::unsafe_arena_release_copy_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.copy_stmt) if (_internal_has_copy_stmt()) { clear_has_node(); ::pg_query::CopyStmt* temp = _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* copy_stmt) { clear_node(); if (copy_stmt) { set_has_copy_stmt(); _impl_.node_.copy_stmt_ = copy_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.copy_stmt) } inline ::pg_query::CopyStmt* Node::_internal_mutable_copy_stmt() { if (!_internal_has_copy_stmt()) { clear_node(); set_has_copy_stmt(); _impl_.node_.copy_stmt_ = CreateMaybeMessage< ::pg_query::CopyStmt >(GetArenaForAllocation()); } return _impl_.node_.copy_stmt_; } inline ::pg_query::CopyStmt* Node::mutable_copy_stmt() { ::pg_query::CopyStmt* _msg = _internal_mutable_copy_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.copy_stmt) return _msg; } // .pg_query.CreateStmt create_stmt = 71 [json_name = "CreateStmt"]; inline bool Node::_internal_has_create_stmt() const { return node_case() == kCreateStmt; } inline bool Node::has_create_stmt() const { return _internal_has_create_stmt(); } inline void Node::set_has_create_stmt() { _impl_._oneof_case_[0] = kCreateStmt; } inline void Node::clear_create_stmt() { if (_internal_has_create_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_create_stmt()) { clear_has_node(); ::pg_query::CreateStmt* temp = _impl_.node_.create_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.create_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::CreateStmt& Node::_internal_create_stmt() const { return _internal_has_create_stmt() ? *_impl_.node_.create_stmt_ : reinterpret_cast< ::pg_query::CreateStmt&>(::pg_query::_CreateStmt_default_instance_); } inline const ::pg_query::CreateStmt& Node::create_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.create_stmt) return _internal_create_stmt(); } inline ::pg_query::CreateStmt* Node::unsafe_arena_release_create_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_stmt) if (_internal_has_create_stmt()) { clear_has_node(); ::pg_query::CreateStmt* temp = _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* create_stmt) { clear_node(); if (create_stmt) { set_has_create_stmt(); _impl_.node_.create_stmt_ = create_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_stmt) } inline ::pg_query::CreateStmt* Node::_internal_mutable_create_stmt() { if (!_internal_has_create_stmt()) { clear_node(); set_has_create_stmt(); _impl_.node_.create_stmt_ = CreateMaybeMessage< ::pg_query::CreateStmt >(GetArenaForAllocation()); } return _impl_.node_.create_stmt_; } inline ::pg_query::CreateStmt* Node::mutable_create_stmt() { ::pg_query::CreateStmt* _msg = _internal_mutable_create_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.create_stmt) return _msg; } // .pg_query.DefineStmt define_stmt = 72 [json_name = "DefineStmt"]; inline bool Node::_internal_has_define_stmt() const { return node_case() == kDefineStmt; } inline bool Node::has_define_stmt() const { return _internal_has_define_stmt(); } inline void Node::set_has_define_stmt() { _impl_._oneof_case_[0] = kDefineStmt; } inline void Node::clear_define_stmt() { if (_internal_has_define_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_define_stmt()) { clear_has_node(); ::pg_query::DefineStmt* temp = _impl_.node_.define_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.define_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::DefineStmt& Node::_internal_define_stmt() const { return _internal_has_define_stmt() ? *_impl_.node_.define_stmt_ : reinterpret_cast< ::pg_query::DefineStmt&>(::pg_query::_DefineStmt_default_instance_); } inline const ::pg_query::DefineStmt& Node::define_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.define_stmt) return _internal_define_stmt(); } inline ::pg_query::DefineStmt* Node::unsafe_arena_release_define_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.define_stmt) if (_internal_has_define_stmt()) { clear_has_node(); ::pg_query::DefineStmt* temp = _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* define_stmt) { clear_node(); if (define_stmt) { set_has_define_stmt(); _impl_.node_.define_stmt_ = define_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.define_stmt) } inline ::pg_query::DefineStmt* Node::_internal_mutable_define_stmt() { if (!_internal_has_define_stmt()) { clear_node(); set_has_define_stmt(); _impl_.node_.define_stmt_ = CreateMaybeMessage< ::pg_query::DefineStmt >(GetArenaForAllocation()); } return _impl_.node_.define_stmt_; } inline ::pg_query::DefineStmt* Node::mutable_define_stmt() { ::pg_query::DefineStmt* _msg = _internal_mutable_define_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.define_stmt) return _msg; } // .pg_query.DropStmt drop_stmt = 73 [json_name = "DropStmt"]; inline bool Node::_internal_has_drop_stmt() const { return node_case() == kDropStmt; } inline bool Node::has_drop_stmt() const { return _internal_has_drop_stmt(); } inline void Node::set_has_drop_stmt() { _impl_._oneof_case_[0] = kDropStmt; } inline void Node::clear_drop_stmt() { if (_internal_has_drop_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_drop_stmt()) { clear_has_node(); ::pg_query::DropStmt* temp = _impl_.node_.drop_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.drop_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::DropStmt& Node::_internal_drop_stmt() const { return _internal_has_drop_stmt() ? *_impl_.node_.drop_stmt_ : reinterpret_cast< ::pg_query::DropStmt&>(::pg_query::_DropStmt_default_instance_); } inline const ::pg_query::DropStmt& Node::drop_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.drop_stmt) return _internal_drop_stmt(); } inline ::pg_query::DropStmt* Node::unsafe_arena_release_drop_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.drop_stmt) if (_internal_has_drop_stmt()) { clear_has_node(); ::pg_query::DropStmt* temp = _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* drop_stmt) { clear_node(); if (drop_stmt) { set_has_drop_stmt(); _impl_.node_.drop_stmt_ = drop_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.drop_stmt) } inline ::pg_query::DropStmt* Node::_internal_mutable_drop_stmt() { if (!_internal_has_drop_stmt()) { clear_node(); set_has_drop_stmt(); _impl_.node_.drop_stmt_ = CreateMaybeMessage< ::pg_query::DropStmt >(GetArenaForAllocation()); } return _impl_.node_.drop_stmt_; } inline ::pg_query::DropStmt* Node::mutable_drop_stmt() { ::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 = 74 [json_name = "TruncateStmt"]; inline bool Node::_internal_has_truncate_stmt() const { return node_case() == kTruncateStmt; } inline bool Node::has_truncate_stmt() const { return _internal_has_truncate_stmt(); } inline void Node::set_has_truncate_stmt() { _impl_._oneof_case_[0] = kTruncateStmt; } inline void Node::clear_truncate_stmt() { if (_internal_has_truncate_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_truncate_stmt()) { clear_has_node(); ::pg_query::TruncateStmt* temp = _impl_.node_.truncate_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.truncate_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::TruncateStmt& Node::_internal_truncate_stmt() const { return _internal_has_truncate_stmt() ? *_impl_.node_.truncate_stmt_ : reinterpret_cast< ::pg_query::TruncateStmt&>(::pg_query::_TruncateStmt_default_instance_); } inline const ::pg_query::TruncateStmt& Node::truncate_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.truncate_stmt) return _internal_truncate_stmt(); } inline ::pg_query::TruncateStmt* Node::unsafe_arena_release_truncate_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.truncate_stmt) if (_internal_has_truncate_stmt()) { clear_has_node(); ::pg_query::TruncateStmt* temp = _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* truncate_stmt) { clear_node(); if (truncate_stmt) { set_has_truncate_stmt(); _impl_.node_.truncate_stmt_ = truncate_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.truncate_stmt) } inline ::pg_query::TruncateStmt* Node::_internal_mutable_truncate_stmt() { if (!_internal_has_truncate_stmt()) { clear_node(); set_has_truncate_stmt(); _impl_.node_.truncate_stmt_ = CreateMaybeMessage< ::pg_query::TruncateStmt >(GetArenaForAllocation()); } return _impl_.node_.truncate_stmt_; } inline ::pg_query::TruncateStmt* Node::mutable_truncate_stmt() { ::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 = 75 [json_name = "CommentStmt"]; inline bool Node::_internal_has_comment_stmt() const { return node_case() == kCommentStmt; } inline bool Node::has_comment_stmt() const { return _internal_has_comment_stmt(); } inline void Node::set_has_comment_stmt() { _impl_._oneof_case_[0] = kCommentStmt; } inline void Node::clear_comment_stmt() { if (_internal_has_comment_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_comment_stmt()) { clear_has_node(); ::pg_query::CommentStmt* temp = _impl_.node_.comment_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.comment_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::CommentStmt& Node::_internal_comment_stmt() const { return _internal_has_comment_stmt() ? *_impl_.node_.comment_stmt_ : reinterpret_cast< ::pg_query::CommentStmt&>(::pg_query::_CommentStmt_default_instance_); } inline const ::pg_query::CommentStmt& Node::comment_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.comment_stmt) return _internal_comment_stmt(); } inline ::pg_query::CommentStmt* Node::unsafe_arena_release_comment_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.comment_stmt) if (_internal_has_comment_stmt()) { clear_has_node(); ::pg_query::CommentStmt* temp = _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* comment_stmt) { clear_node(); if (comment_stmt) { set_has_comment_stmt(); _impl_.node_.comment_stmt_ = comment_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.comment_stmt) } inline ::pg_query::CommentStmt* Node::_internal_mutable_comment_stmt() { if (!_internal_has_comment_stmt()) { clear_node(); set_has_comment_stmt(); _impl_.node_.comment_stmt_ = CreateMaybeMessage< ::pg_query::CommentStmt >(GetArenaForAllocation()); } return _impl_.node_.comment_stmt_; } inline ::pg_query::CommentStmt* Node::mutable_comment_stmt() { ::pg_query::CommentStmt* _msg = _internal_mutable_comment_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.comment_stmt) return _msg; } // .pg_query.FetchStmt fetch_stmt = 76 [json_name = "FetchStmt"]; inline bool Node::_internal_has_fetch_stmt() const { return node_case() == kFetchStmt; } inline bool Node::has_fetch_stmt() const { return _internal_has_fetch_stmt(); } inline void Node::set_has_fetch_stmt() { _impl_._oneof_case_[0] = kFetchStmt; } inline void Node::clear_fetch_stmt() { if (_internal_has_fetch_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_fetch_stmt()) { clear_has_node(); ::pg_query::FetchStmt* temp = _impl_.node_.fetch_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.fetch_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::FetchStmt& Node::_internal_fetch_stmt() const { return _internal_has_fetch_stmt() ? *_impl_.node_.fetch_stmt_ : reinterpret_cast< ::pg_query::FetchStmt&>(::pg_query::_FetchStmt_default_instance_); } inline const ::pg_query::FetchStmt& Node::fetch_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.fetch_stmt) return _internal_fetch_stmt(); } inline ::pg_query::FetchStmt* Node::unsafe_arena_release_fetch_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.fetch_stmt) if (_internal_has_fetch_stmt()) { clear_has_node(); ::pg_query::FetchStmt* temp = _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* fetch_stmt) { clear_node(); if (fetch_stmt) { set_has_fetch_stmt(); _impl_.node_.fetch_stmt_ = fetch_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.fetch_stmt) } inline ::pg_query::FetchStmt* Node::_internal_mutable_fetch_stmt() { if (!_internal_has_fetch_stmt()) { clear_node(); set_has_fetch_stmt(); _impl_.node_.fetch_stmt_ = CreateMaybeMessage< ::pg_query::FetchStmt >(GetArenaForAllocation()); } return _impl_.node_.fetch_stmt_; } inline ::pg_query::FetchStmt* Node::mutable_fetch_stmt() { ::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 = 77 [json_name = "IndexStmt"]; inline bool Node::_internal_has_index_stmt() const { return node_case() == kIndexStmt; } inline bool Node::has_index_stmt() const { return _internal_has_index_stmt(); } inline void Node::set_has_index_stmt() { _impl_._oneof_case_[0] = kIndexStmt; } inline void Node::clear_index_stmt() { if (_internal_has_index_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_index_stmt()) { clear_has_node(); ::pg_query::IndexStmt* temp = _impl_.node_.index_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.index_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::IndexStmt& Node::_internal_index_stmt() const { return _internal_has_index_stmt() ? *_impl_.node_.index_stmt_ : reinterpret_cast< ::pg_query::IndexStmt&>(::pg_query::_IndexStmt_default_instance_); } inline const ::pg_query::IndexStmt& Node::index_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.index_stmt) return _internal_index_stmt(); } inline ::pg_query::IndexStmt* Node::unsafe_arena_release_index_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.index_stmt) if (_internal_has_index_stmt()) { clear_has_node(); ::pg_query::IndexStmt* temp = _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* index_stmt) { clear_node(); if (index_stmt) { set_has_index_stmt(); _impl_.node_.index_stmt_ = index_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.index_stmt) } inline ::pg_query::IndexStmt* Node::_internal_mutable_index_stmt() { if (!_internal_has_index_stmt()) { clear_node(); set_has_index_stmt(); _impl_.node_.index_stmt_ = CreateMaybeMessage< ::pg_query::IndexStmt >(GetArenaForAllocation()); } return _impl_.node_.index_stmt_; } inline ::pg_query::IndexStmt* Node::mutable_index_stmt() { ::pg_query::IndexStmt* _msg = _internal_mutable_index_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.index_stmt) return _msg; } // .pg_query.CreateFunctionStmt create_function_stmt = 78 [json_name = "CreateFunctionStmt"]; inline bool Node::_internal_has_create_function_stmt() const { return node_case() == kCreateFunctionStmt; } inline bool Node::has_create_function_stmt() const { return _internal_has_create_function_stmt(); } inline void Node::set_has_create_function_stmt() { _impl_._oneof_case_[0] = kCreateFunctionStmt; } inline void Node::clear_create_function_stmt() { if (_internal_has_create_function_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_create_function_stmt()) { clear_has_node(); ::pg_query::CreateFunctionStmt* temp = _impl_.node_.create_function_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_create_function_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.create_function_stmt) return _internal_create_function_stmt(); } inline ::pg_query::CreateFunctionStmt* Node::unsafe_arena_release_create_function_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_function_stmt) if (_internal_has_create_function_stmt()) { clear_has_node(); ::pg_query::CreateFunctionStmt* temp = _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* create_function_stmt) { clear_node(); if (create_function_stmt) { set_has_create_function_stmt(); _impl_.node_.create_function_stmt_ = create_function_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_function_stmt) } inline ::pg_query::CreateFunctionStmt* Node::_internal_mutable_create_function_stmt() { if (!_internal_has_create_function_stmt()) { clear_node(); set_has_create_function_stmt(); _impl_.node_.create_function_stmt_ = CreateMaybeMessage< ::pg_query::CreateFunctionStmt >(GetArenaForAllocation()); } return _impl_.node_.create_function_stmt_; } inline ::pg_query::CreateFunctionStmt* Node::mutable_create_function_stmt() { ::pg_query::CreateFunctionStmt* _msg = _internal_mutable_create_function_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.create_function_stmt) return _msg; } // .pg_query.AlterFunctionStmt alter_function_stmt = 79 [json_name = "AlterFunctionStmt"]; inline bool Node::_internal_has_alter_function_stmt() const { return node_case() == kAlterFunctionStmt; } inline bool Node::has_alter_function_stmt() const { return _internal_has_alter_function_stmt(); } inline void Node::set_has_alter_function_stmt() { _impl_._oneof_case_[0] = kAlterFunctionStmt; } inline void Node::clear_alter_function_stmt() { if (_internal_has_alter_function_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_function_stmt()) { clear_has_node(); ::pg_query::AlterFunctionStmt* temp = _impl_.node_.alter_function_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_function_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_function_stmt) return _internal_alter_function_stmt(); } inline ::pg_query::AlterFunctionStmt* Node::unsafe_arena_release_alter_function_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_function_stmt) if (_internal_has_alter_function_stmt()) { clear_has_node(); ::pg_query::AlterFunctionStmt* temp = _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* alter_function_stmt) { clear_node(); if (alter_function_stmt) { set_has_alter_function_stmt(); _impl_.node_.alter_function_stmt_ = alter_function_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_function_stmt) } inline ::pg_query::AlterFunctionStmt* Node::_internal_mutable_alter_function_stmt() { if (!_internal_has_alter_function_stmt()) { clear_node(); set_has_alter_function_stmt(); _impl_.node_.alter_function_stmt_ = CreateMaybeMessage< ::pg_query::AlterFunctionStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_function_stmt_; } inline ::pg_query::AlterFunctionStmt* Node::mutable_alter_function_stmt() { ::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 = 80 [json_name = "DoStmt"]; inline bool Node::_internal_has_do_stmt() const { return node_case() == kDoStmt; } inline bool Node::has_do_stmt() const { return _internal_has_do_stmt(); } inline void Node::set_has_do_stmt() { _impl_._oneof_case_[0] = kDoStmt; } inline void Node::clear_do_stmt() { if (_internal_has_do_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_do_stmt()) { clear_has_node(); ::pg_query::DoStmt* temp = _impl_.node_.do_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.do_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::DoStmt& Node::_internal_do_stmt() const { return _internal_has_do_stmt() ? *_impl_.node_.do_stmt_ : reinterpret_cast< ::pg_query::DoStmt&>(::pg_query::_DoStmt_default_instance_); } inline const ::pg_query::DoStmt& Node::do_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.do_stmt) return _internal_do_stmt(); } inline ::pg_query::DoStmt* Node::unsafe_arena_release_do_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.do_stmt) if (_internal_has_do_stmt()) { clear_has_node(); ::pg_query::DoStmt* temp = _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* do_stmt) { clear_node(); if (do_stmt) { set_has_do_stmt(); _impl_.node_.do_stmt_ = do_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.do_stmt) } inline ::pg_query::DoStmt* Node::_internal_mutable_do_stmt() { if (!_internal_has_do_stmt()) { clear_node(); set_has_do_stmt(); _impl_.node_.do_stmt_ = CreateMaybeMessage< ::pg_query::DoStmt >(GetArenaForAllocation()); } return _impl_.node_.do_stmt_; } inline ::pg_query::DoStmt* Node::mutable_do_stmt() { ::pg_query::DoStmt* _msg = _internal_mutable_do_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.do_stmt) return _msg; } // .pg_query.RenameStmt rename_stmt = 81 [json_name = "RenameStmt"]; inline bool Node::_internal_has_rename_stmt() const { return node_case() == kRenameStmt; } inline bool Node::has_rename_stmt() const { return _internal_has_rename_stmt(); } inline void Node::set_has_rename_stmt() { _impl_._oneof_case_[0] = kRenameStmt; } inline void Node::clear_rename_stmt() { if (_internal_has_rename_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_rename_stmt()) { clear_has_node(); ::pg_query::RenameStmt* temp = _impl_.node_.rename_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.rename_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::RenameStmt& Node::_internal_rename_stmt() const { return _internal_has_rename_stmt() ? *_impl_.node_.rename_stmt_ : reinterpret_cast< ::pg_query::RenameStmt&>(::pg_query::_RenameStmt_default_instance_); } inline const ::pg_query::RenameStmt& Node::rename_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.rename_stmt) return _internal_rename_stmt(); } inline ::pg_query::RenameStmt* Node::unsafe_arena_release_rename_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.rename_stmt) if (_internal_has_rename_stmt()) { clear_has_node(); ::pg_query::RenameStmt* temp = _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* rename_stmt) { clear_node(); if (rename_stmt) { set_has_rename_stmt(); _impl_.node_.rename_stmt_ = rename_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.rename_stmt) } inline ::pg_query::RenameStmt* Node::_internal_mutable_rename_stmt() { if (!_internal_has_rename_stmt()) { clear_node(); set_has_rename_stmt(); _impl_.node_.rename_stmt_ = CreateMaybeMessage< ::pg_query::RenameStmt >(GetArenaForAllocation()); } return _impl_.node_.rename_stmt_; } inline ::pg_query::RenameStmt* Node::mutable_rename_stmt() { ::pg_query::RenameStmt* _msg = _internal_mutable_rename_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.rename_stmt) return _msg; } // .pg_query.RuleStmt rule_stmt = 82 [json_name = "RuleStmt"]; inline bool Node::_internal_has_rule_stmt() const { return node_case() == kRuleStmt; } inline bool Node::has_rule_stmt() const { return _internal_has_rule_stmt(); } inline void Node::set_has_rule_stmt() { _impl_._oneof_case_[0] = kRuleStmt; } inline void Node::clear_rule_stmt() { if (_internal_has_rule_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_rule_stmt()) { clear_has_node(); ::pg_query::RuleStmt* temp = _impl_.node_.rule_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.rule_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::RuleStmt& Node::_internal_rule_stmt() const { return _internal_has_rule_stmt() ? *_impl_.node_.rule_stmt_ : reinterpret_cast< ::pg_query::RuleStmt&>(::pg_query::_RuleStmt_default_instance_); } inline const ::pg_query::RuleStmt& Node::rule_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.rule_stmt) return _internal_rule_stmt(); } inline ::pg_query::RuleStmt* Node::unsafe_arena_release_rule_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.rule_stmt) if (_internal_has_rule_stmt()) { clear_has_node(); ::pg_query::RuleStmt* temp = _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* rule_stmt) { clear_node(); if (rule_stmt) { set_has_rule_stmt(); _impl_.node_.rule_stmt_ = rule_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.rule_stmt) } inline ::pg_query::RuleStmt* Node::_internal_mutable_rule_stmt() { if (!_internal_has_rule_stmt()) { clear_node(); set_has_rule_stmt(); _impl_.node_.rule_stmt_ = CreateMaybeMessage< ::pg_query::RuleStmt >(GetArenaForAllocation()); } return _impl_.node_.rule_stmt_; } inline ::pg_query::RuleStmt* Node::mutable_rule_stmt() { ::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 = 83 [json_name = "NotifyStmt"]; inline bool Node::_internal_has_notify_stmt() const { return node_case() == kNotifyStmt; } inline bool Node::has_notify_stmt() const { return _internal_has_notify_stmt(); } inline void Node::set_has_notify_stmt() { _impl_._oneof_case_[0] = kNotifyStmt; } inline void Node::clear_notify_stmt() { if (_internal_has_notify_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_notify_stmt()) { clear_has_node(); ::pg_query::NotifyStmt* temp = _impl_.node_.notify_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.notify_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::NotifyStmt& Node::_internal_notify_stmt() const { return _internal_has_notify_stmt() ? *_impl_.node_.notify_stmt_ : reinterpret_cast< ::pg_query::NotifyStmt&>(::pg_query::_NotifyStmt_default_instance_); } inline const ::pg_query::NotifyStmt& Node::notify_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.notify_stmt) return _internal_notify_stmt(); } inline ::pg_query::NotifyStmt* Node::unsafe_arena_release_notify_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.notify_stmt) if (_internal_has_notify_stmt()) { clear_has_node(); ::pg_query::NotifyStmt* temp = _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* notify_stmt) { clear_node(); if (notify_stmt) { set_has_notify_stmt(); _impl_.node_.notify_stmt_ = notify_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.notify_stmt) } inline ::pg_query::NotifyStmt* Node::_internal_mutable_notify_stmt() { if (!_internal_has_notify_stmt()) { clear_node(); set_has_notify_stmt(); _impl_.node_.notify_stmt_ = CreateMaybeMessage< ::pg_query::NotifyStmt >(GetArenaForAllocation()); } return _impl_.node_.notify_stmt_; } inline ::pg_query::NotifyStmt* Node::mutable_notify_stmt() { ::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 = 84 [json_name = "ListenStmt"]; inline bool Node::_internal_has_listen_stmt() const { return node_case() == kListenStmt; } inline bool Node::has_listen_stmt() const { return _internal_has_listen_stmt(); } inline void Node::set_has_listen_stmt() { _impl_._oneof_case_[0] = kListenStmt; } inline void Node::clear_listen_stmt() { if (_internal_has_listen_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_listen_stmt()) { clear_has_node(); ::pg_query::ListenStmt* temp = _impl_.node_.listen_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.listen_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::ListenStmt& Node::_internal_listen_stmt() const { return _internal_has_listen_stmt() ? *_impl_.node_.listen_stmt_ : reinterpret_cast< ::pg_query::ListenStmt&>(::pg_query::_ListenStmt_default_instance_); } inline const ::pg_query::ListenStmt& Node::listen_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.listen_stmt) return _internal_listen_stmt(); } inline ::pg_query::ListenStmt* Node::unsafe_arena_release_listen_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.listen_stmt) if (_internal_has_listen_stmt()) { clear_has_node(); ::pg_query::ListenStmt* temp = _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* listen_stmt) { clear_node(); if (listen_stmt) { set_has_listen_stmt(); _impl_.node_.listen_stmt_ = listen_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.listen_stmt) } inline ::pg_query::ListenStmt* Node::_internal_mutable_listen_stmt() { if (!_internal_has_listen_stmt()) { clear_node(); set_has_listen_stmt(); _impl_.node_.listen_stmt_ = CreateMaybeMessage< ::pg_query::ListenStmt >(GetArenaForAllocation()); } return _impl_.node_.listen_stmt_; } inline ::pg_query::ListenStmt* Node::mutable_listen_stmt() { ::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 = 85 [json_name = "UnlistenStmt"]; inline bool Node::_internal_has_unlisten_stmt() const { return node_case() == kUnlistenStmt; } inline bool Node::has_unlisten_stmt() const { return _internal_has_unlisten_stmt(); } inline void Node::set_has_unlisten_stmt() { _impl_._oneof_case_[0] = kUnlistenStmt; } inline void Node::clear_unlisten_stmt() { if (_internal_has_unlisten_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_unlisten_stmt()) { clear_has_node(); ::pg_query::UnlistenStmt* temp = _impl_.node_.unlisten_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.unlisten_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::UnlistenStmt& Node::_internal_unlisten_stmt() const { return _internal_has_unlisten_stmt() ? *_impl_.node_.unlisten_stmt_ : reinterpret_cast< ::pg_query::UnlistenStmt&>(::pg_query::_UnlistenStmt_default_instance_); } inline const ::pg_query::UnlistenStmt& Node::unlisten_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.unlisten_stmt) return _internal_unlisten_stmt(); } inline ::pg_query::UnlistenStmt* Node::unsafe_arena_release_unlisten_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.unlisten_stmt) if (_internal_has_unlisten_stmt()) { clear_has_node(); ::pg_query::UnlistenStmt* temp = _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* unlisten_stmt) { clear_node(); if (unlisten_stmt) { set_has_unlisten_stmt(); _impl_.node_.unlisten_stmt_ = unlisten_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.unlisten_stmt) } inline ::pg_query::UnlistenStmt* Node::_internal_mutable_unlisten_stmt() { if (!_internal_has_unlisten_stmt()) { clear_node(); set_has_unlisten_stmt(); _impl_.node_.unlisten_stmt_ = CreateMaybeMessage< ::pg_query::UnlistenStmt >(GetArenaForAllocation()); } return _impl_.node_.unlisten_stmt_; } inline ::pg_query::UnlistenStmt* Node::mutable_unlisten_stmt() { ::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 = 86 [json_name = "TransactionStmt"]; inline bool Node::_internal_has_transaction_stmt() const { return node_case() == kTransactionStmt; } inline bool Node::has_transaction_stmt() const { return _internal_has_transaction_stmt(); } inline void Node::set_has_transaction_stmt() { _impl_._oneof_case_[0] = kTransactionStmt; } inline void Node::clear_transaction_stmt() { if (_internal_has_transaction_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_transaction_stmt()) { clear_has_node(); ::pg_query::TransactionStmt* temp = _impl_.node_.transaction_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.transaction_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::TransactionStmt& Node::_internal_transaction_stmt() const { return _internal_has_transaction_stmt() ? *_impl_.node_.transaction_stmt_ : reinterpret_cast< ::pg_query::TransactionStmt&>(::pg_query::_TransactionStmt_default_instance_); } inline const ::pg_query::TransactionStmt& Node::transaction_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.transaction_stmt) return _internal_transaction_stmt(); } inline ::pg_query::TransactionStmt* Node::unsafe_arena_release_transaction_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.transaction_stmt) if (_internal_has_transaction_stmt()) { clear_has_node(); ::pg_query::TransactionStmt* temp = _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* transaction_stmt) { clear_node(); if (transaction_stmt) { set_has_transaction_stmt(); _impl_.node_.transaction_stmt_ = transaction_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.transaction_stmt) } inline ::pg_query::TransactionStmt* Node::_internal_mutable_transaction_stmt() { if (!_internal_has_transaction_stmt()) { clear_node(); set_has_transaction_stmt(); _impl_.node_.transaction_stmt_ = CreateMaybeMessage< ::pg_query::TransactionStmt >(GetArenaForAllocation()); } return _impl_.node_.transaction_stmt_; } inline ::pg_query::TransactionStmt* Node::mutable_transaction_stmt() { ::pg_query::TransactionStmt* _msg = _internal_mutable_transaction_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.transaction_stmt) return _msg; } // .pg_query.ViewStmt view_stmt = 87 [json_name = "ViewStmt"]; inline bool Node::_internal_has_view_stmt() const { return node_case() == kViewStmt; } inline bool Node::has_view_stmt() const { return _internal_has_view_stmt(); } inline void Node::set_has_view_stmt() { _impl_._oneof_case_[0] = kViewStmt; } inline void Node::clear_view_stmt() { if (_internal_has_view_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_view_stmt()) { clear_has_node(); ::pg_query::ViewStmt* temp = _impl_.node_.view_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.view_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::ViewStmt& Node::_internal_view_stmt() const { return _internal_has_view_stmt() ? *_impl_.node_.view_stmt_ : reinterpret_cast< ::pg_query::ViewStmt&>(::pg_query::_ViewStmt_default_instance_); } inline const ::pg_query::ViewStmt& Node::view_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.view_stmt) return _internal_view_stmt(); } inline ::pg_query::ViewStmt* Node::unsafe_arena_release_view_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.view_stmt) if (_internal_has_view_stmt()) { clear_has_node(); ::pg_query::ViewStmt* temp = _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* view_stmt) { clear_node(); if (view_stmt) { set_has_view_stmt(); _impl_.node_.view_stmt_ = view_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.view_stmt) } inline ::pg_query::ViewStmt* Node::_internal_mutable_view_stmt() { if (!_internal_has_view_stmt()) { clear_node(); set_has_view_stmt(); _impl_.node_.view_stmt_ = CreateMaybeMessage< ::pg_query::ViewStmt >(GetArenaForAllocation()); } return _impl_.node_.view_stmt_; } inline ::pg_query::ViewStmt* Node::mutable_view_stmt() { ::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 = 88 [json_name = "LoadStmt"]; inline bool Node::_internal_has_load_stmt() const { return node_case() == kLoadStmt; } inline bool Node::has_load_stmt() const { return _internal_has_load_stmt(); } inline void Node::set_has_load_stmt() { _impl_._oneof_case_[0] = kLoadStmt; } inline void Node::clear_load_stmt() { if (_internal_has_load_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_load_stmt()) { clear_has_node(); ::pg_query::LoadStmt* temp = _impl_.node_.load_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.load_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::LoadStmt& Node::_internal_load_stmt() const { return _internal_has_load_stmt() ? *_impl_.node_.load_stmt_ : reinterpret_cast< ::pg_query::LoadStmt&>(::pg_query::_LoadStmt_default_instance_); } inline const ::pg_query::LoadStmt& Node::load_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.load_stmt) return _internal_load_stmt(); } inline ::pg_query::LoadStmt* Node::unsafe_arena_release_load_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.load_stmt) if (_internal_has_load_stmt()) { clear_has_node(); ::pg_query::LoadStmt* temp = _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* load_stmt) { clear_node(); if (load_stmt) { set_has_load_stmt(); _impl_.node_.load_stmt_ = load_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.load_stmt) } inline ::pg_query::LoadStmt* Node::_internal_mutable_load_stmt() { if (!_internal_has_load_stmt()) { clear_node(); set_has_load_stmt(); _impl_.node_.load_stmt_ = CreateMaybeMessage< ::pg_query::LoadStmt >(GetArenaForAllocation()); } return _impl_.node_.load_stmt_; } inline ::pg_query::LoadStmt* Node::mutable_load_stmt() { ::pg_query::LoadStmt* _msg = _internal_mutable_load_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.load_stmt) return _msg; } // .pg_query.CreateDomainStmt create_domain_stmt = 89 [json_name = "CreateDomainStmt"]; inline bool Node::_internal_has_create_domain_stmt() const { return node_case() == kCreateDomainStmt; } inline bool Node::has_create_domain_stmt() const { return _internal_has_create_domain_stmt(); } inline void Node::set_has_create_domain_stmt() { _impl_._oneof_case_[0] = kCreateDomainStmt; } inline void Node::clear_create_domain_stmt() { if (_internal_has_create_domain_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_create_domain_stmt()) { clear_has_node(); ::pg_query::CreateDomainStmt* temp = _impl_.node_.create_domain_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_create_domain_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.create_domain_stmt) return _internal_create_domain_stmt(); } inline ::pg_query::CreateDomainStmt* Node::unsafe_arena_release_create_domain_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_domain_stmt) if (_internal_has_create_domain_stmt()) { clear_has_node(); ::pg_query::CreateDomainStmt* temp = _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* create_domain_stmt) { clear_node(); if (create_domain_stmt) { set_has_create_domain_stmt(); _impl_.node_.create_domain_stmt_ = create_domain_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_domain_stmt) } inline ::pg_query::CreateDomainStmt* Node::_internal_mutable_create_domain_stmt() { if (!_internal_has_create_domain_stmt()) { clear_node(); set_has_create_domain_stmt(); _impl_.node_.create_domain_stmt_ = CreateMaybeMessage< ::pg_query::CreateDomainStmt >(GetArenaForAllocation()); } return _impl_.node_.create_domain_stmt_; } inline ::pg_query::CreateDomainStmt* Node::mutable_create_domain_stmt() { ::pg_query::CreateDomainStmt* _msg = _internal_mutable_create_domain_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.create_domain_stmt) return _msg; } // .pg_query.CreatedbStmt createdb_stmt = 90 [json_name = "CreatedbStmt"]; inline bool Node::_internal_has_createdb_stmt() const { return node_case() == kCreatedbStmt; } inline bool Node::has_createdb_stmt() const { return _internal_has_createdb_stmt(); } inline void Node::set_has_createdb_stmt() { _impl_._oneof_case_[0] = kCreatedbStmt; } inline void Node::clear_createdb_stmt() { if (_internal_has_createdb_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_createdb_stmt()) { clear_has_node(); ::pg_query::CreatedbStmt* temp = _impl_.node_.createdb_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.createdb_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::CreatedbStmt& Node::_internal_createdb_stmt() const { return _internal_has_createdb_stmt() ? *_impl_.node_.createdb_stmt_ : reinterpret_cast< ::pg_query::CreatedbStmt&>(::pg_query::_CreatedbStmt_default_instance_); } inline const ::pg_query::CreatedbStmt& Node::createdb_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.createdb_stmt) return _internal_createdb_stmt(); } inline ::pg_query::CreatedbStmt* Node::unsafe_arena_release_createdb_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.createdb_stmt) if (_internal_has_createdb_stmt()) { clear_has_node(); ::pg_query::CreatedbStmt* temp = _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* createdb_stmt) { clear_node(); if (createdb_stmt) { set_has_createdb_stmt(); _impl_.node_.createdb_stmt_ = createdb_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.createdb_stmt) } inline ::pg_query::CreatedbStmt* Node::_internal_mutable_createdb_stmt() { if (!_internal_has_createdb_stmt()) { clear_node(); set_has_createdb_stmt(); _impl_.node_.createdb_stmt_ = CreateMaybeMessage< ::pg_query::CreatedbStmt >(GetArenaForAllocation()); } return _impl_.node_.createdb_stmt_; } inline ::pg_query::CreatedbStmt* Node::mutable_createdb_stmt() { ::pg_query::CreatedbStmt* _msg = _internal_mutable_createdb_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.createdb_stmt) return _msg; } // .pg_query.DropdbStmt dropdb_stmt = 91 [json_name = "DropdbStmt"]; inline bool Node::_internal_has_dropdb_stmt() const { return node_case() == kDropdbStmt; } inline bool Node::has_dropdb_stmt() const { return _internal_has_dropdb_stmt(); } inline void Node::set_has_dropdb_stmt() { _impl_._oneof_case_[0] = kDropdbStmt; } inline void Node::clear_dropdb_stmt() { if (_internal_has_dropdb_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_dropdb_stmt()) { clear_has_node(); ::pg_query::DropdbStmt* temp = _impl_.node_.dropdb_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.dropdb_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::DropdbStmt& Node::_internal_dropdb_stmt() const { return _internal_has_dropdb_stmt() ? *_impl_.node_.dropdb_stmt_ : reinterpret_cast< ::pg_query::DropdbStmt&>(::pg_query::_DropdbStmt_default_instance_); } inline const ::pg_query::DropdbStmt& Node::dropdb_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.dropdb_stmt) return _internal_dropdb_stmt(); } inline ::pg_query::DropdbStmt* Node::unsafe_arena_release_dropdb_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.dropdb_stmt) if (_internal_has_dropdb_stmt()) { clear_has_node(); ::pg_query::DropdbStmt* temp = _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* dropdb_stmt) { clear_node(); if (dropdb_stmt) { set_has_dropdb_stmt(); _impl_.node_.dropdb_stmt_ = dropdb_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.dropdb_stmt) } inline ::pg_query::DropdbStmt* Node::_internal_mutable_dropdb_stmt() { if (!_internal_has_dropdb_stmt()) { clear_node(); set_has_dropdb_stmt(); _impl_.node_.dropdb_stmt_ = CreateMaybeMessage< ::pg_query::DropdbStmt >(GetArenaForAllocation()); } return _impl_.node_.dropdb_stmt_; } inline ::pg_query::DropdbStmt* Node::mutable_dropdb_stmt() { ::pg_query::DropdbStmt* _msg = _internal_mutable_dropdb_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.dropdb_stmt) return _msg; } // .pg_query.VacuumStmt vacuum_stmt = 92 [json_name = "VacuumStmt"]; inline bool Node::_internal_has_vacuum_stmt() const { return node_case() == kVacuumStmt; } inline bool Node::has_vacuum_stmt() const { return _internal_has_vacuum_stmt(); } inline void Node::set_has_vacuum_stmt() { _impl_._oneof_case_[0] = kVacuumStmt; } inline void Node::clear_vacuum_stmt() { if (_internal_has_vacuum_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_vacuum_stmt()) { clear_has_node(); ::pg_query::VacuumStmt* temp = _impl_.node_.vacuum_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.vacuum_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::VacuumStmt& Node::_internal_vacuum_stmt() const { return _internal_has_vacuum_stmt() ? *_impl_.node_.vacuum_stmt_ : reinterpret_cast< ::pg_query::VacuumStmt&>(::pg_query::_VacuumStmt_default_instance_); } inline const ::pg_query::VacuumStmt& Node::vacuum_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.vacuum_stmt) return _internal_vacuum_stmt(); } inline ::pg_query::VacuumStmt* Node::unsafe_arena_release_vacuum_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.vacuum_stmt) if (_internal_has_vacuum_stmt()) { clear_has_node(); ::pg_query::VacuumStmt* temp = _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* vacuum_stmt) { clear_node(); if (vacuum_stmt) { set_has_vacuum_stmt(); _impl_.node_.vacuum_stmt_ = vacuum_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.vacuum_stmt) } inline ::pg_query::VacuumStmt* Node::_internal_mutable_vacuum_stmt() { if (!_internal_has_vacuum_stmt()) { clear_node(); set_has_vacuum_stmt(); _impl_.node_.vacuum_stmt_ = CreateMaybeMessage< ::pg_query::VacuumStmt >(GetArenaForAllocation()); } return _impl_.node_.vacuum_stmt_; } inline ::pg_query::VacuumStmt* Node::mutable_vacuum_stmt() { ::pg_query::VacuumStmt* _msg = _internal_mutable_vacuum_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.vacuum_stmt) return _msg; } // .pg_query.ExplainStmt explain_stmt = 93 [json_name = "ExplainStmt"]; inline bool Node::_internal_has_explain_stmt() const { return node_case() == kExplainStmt; } inline bool Node::has_explain_stmt() const { return _internal_has_explain_stmt(); } inline void Node::set_has_explain_stmt() { _impl_._oneof_case_[0] = kExplainStmt; } inline void Node::clear_explain_stmt() { if (_internal_has_explain_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_explain_stmt()) { clear_has_node(); ::pg_query::ExplainStmt* temp = _impl_.node_.explain_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.explain_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::ExplainStmt& Node::_internal_explain_stmt() const { return _internal_has_explain_stmt() ? *_impl_.node_.explain_stmt_ : reinterpret_cast< ::pg_query::ExplainStmt&>(::pg_query::_ExplainStmt_default_instance_); } inline const ::pg_query::ExplainStmt& Node::explain_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.explain_stmt) return _internal_explain_stmt(); } inline ::pg_query::ExplainStmt* Node::unsafe_arena_release_explain_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.explain_stmt) if (_internal_has_explain_stmt()) { clear_has_node(); ::pg_query::ExplainStmt* temp = _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* explain_stmt) { clear_node(); if (explain_stmt) { set_has_explain_stmt(); _impl_.node_.explain_stmt_ = explain_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.explain_stmt) } inline ::pg_query::ExplainStmt* Node::_internal_mutable_explain_stmt() { if (!_internal_has_explain_stmt()) { clear_node(); set_has_explain_stmt(); _impl_.node_.explain_stmt_ = CreateMaybeMessage< ::pg_query::ExplainStmt >(GetArenaForAllocation()); } return _impl_.node_.explain_stmt_; } inline ::pg_query::ExplainStmt* Node::mutable_explain_stmt() { ::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 = 94 [json_name = "CreateTableAsStmt"]; inline bool Node::_internal_has_create_table_as_stmt() const { return node_case() == kCreateTableAsStmt; } inline bool Node::has_create_table_as_stmt() const { return _internal_has_create_table_as_stmt(); } inline void Node::set_has_create_table_as_stmt() { _impl_._oneof_case_[0] = kCreateTableAsStmt; } inline void Node::clear_create_table_as_stmt() { if (_internal_has_create_table_as_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_create_table_as_stmt()) { clear_has_node(); ::pg_query::CreateTableAsStmt* temp = _impl_.node_.create_table_as_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_create_table_as_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.create_table_as_stmt) return _internal_create_table_as_stmt(); } inline ::pg_query::CreateTableAsStmt* Node::unsafe_arena_release_create_table_as_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_table_as_stmt) if (_internal_has_create_table_as_stmt()) { clear_has_node(); ::pg_query::CreateTableAsStmt* temp = _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* create_table_as_stmt) { clear_node(); if (create_table_as_stmt) { set_has_create_table_as_stmt(); _impl_.node_.create_table_as_stmt_ = create_table_as_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_table_as_stmt) } inline ::pg_query::CreateTableAsStmt* Node::_internal_mutable_create_table_as_stmt() { if (!_internal_has_create_table_as_stmt()) { clear_node(); set_has_create_table_as_stmt(); _impl_.node_.create_table_as_stmt_ = CreateMaybeMessage< ::pg_query::CreateTableAsStmt >(GetArenaForAllocation()); } return _impl_.node_.create_table_as_stmt_; } inline ::pg_query::CreateTableAsStmt* Node::mutable_create_table_as_stmt() { ::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.CreateSeqStmt create_seq_stmt = 95 [json_name = "CreateSeqStmt"]; inline bool Node::_internal_has_create_seq_stmt() const { return node_case() == kCreateSeqStmt; } inline bool Node::has_create_seq_stmt() const { return _internal_has_create_seq_stmt(); } inline void Node::set_has_create_seq_stmt() { _impl_._oneof_case_[0] = kCreateSeqStmt; } inline void Node::clear_create_seq_stmt() { if (_internal_has_create_seq_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_create_seq_stmt()) { clear_has_node(); ::pg_query::CreateSeqStmt* temp = _impl_.node_.create_seq_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_create_seq_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.create_seq_stmt) return _internal_create_seq_stmt(); } inline ::pg_query::CreateSeqStmt* Node::unsafe_arena_release_create_seq_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_seq_stmt) if (_internal_has_create_seq_stmt()) { clear_has_node(); ::pg_query::CreateSeqStmt* temp = _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* create_seq_stmt) { clear_node(); if (create_seq_stmt) { set_has_create_seq_stmt(); _impl_.node_.create_seq_stmt_ = create_seq_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_seq_stmt) } inline ::pg_query::CreateSeqStmt* Node::_internal_mutable_create_seq_stmt() { if (!_internal_has_create_seq_stmt()) { clear_node(); set_has_create_seq_stmt(); _impl_.node_.create_seq_stmt_ = CreateMaybeMessage< ::pg_query::CreateSeqStmt >(GetArenaForAllocation()); } return _impl_.node_.create_seq_stmt_; } inline ::pg_query::CreateSeqStmt* Node::mutable_create_seq_stmt() { ::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 = 96 [json_name = "AlterSeqStmt"]; inline bool Node::_internal_has_alter_seq_stmt() const { return node_case() == kAlterSeqStmt; } inline bool Node::has_alter_seq_stmt() const { return _internal_has_alter_seq_stmt(); } inline void Node::set_has_alter_seq_stmt() { _impl_._oneof_case_[0] = kAlterSeqStmt; } inline void Node::clear_alter_seq_stmt() { if (_internal_has_alter_seq_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_seq_stmt()) { clear_has_node(); ::pg_query::AlterSeqStmt* temp = _impl_.node_.alter_seq_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_seq_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_seq_stmt) return _internal_alter_seq_stmt(); } inline ::pg_query::AlterSeqStmt* Node::unsafe_arena_release_alter_seq_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_seq_stmt) if (_internal_has_alter_seq_stmt()) { clear_has_node(); ::pg_query::AlterSeqStmt* temp = _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* alter_seq_stmt) { clear_node(); if (alter_seq_stmt) { set_has_alter_seq_stmt(); _impl_.node_.alter_seq_stmt_ = alter_seq_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_seq_stmt) } inline ::pg_query::AlterSeqStmt* Node::_internal_mutable_alter_seq_stmt() { if (!_internal_has_alter_seq_stmt()) { clear_node(); set_has_alter_seq_stmt(); _impl_.node_.alter_seq_stmt_ = CreateMaybeMessage< ::pg_query::AlterSeqStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_seq_stmt_; } inline ::pg_query::AlterSeqStmt* Node::mutable_alter_seq_stmt() { ::pg_query::AlterSeqStmt* _msg = _internal_mutable_alter_seq_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_seq_stmt) return _msg; } // .pg_query.VariableSetStmt variable_set_stmt = 97 [json_name = "VariableSetStmt"]; inline bool Node::_internal_has_variable_set_stmt() const { return node_case() == kVariableSetStmt; } inline bool Node::has_variable_set_stmt() const { return _internal_has_variable_set_stmt(); } inline void Node::set_has_variable_set_stmt() { _impl_._oneof_case_[0] = kVariableSetStmt; } inline void Node::clear_variable_set_stmt() { if (_internal_has_variable_set_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_variable_set_stmt()) { clear_has_node(); ::pg_query::VariableSetStmt* temp = _impl_.node_.variable_set_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_variable_set_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.variable_set_stmt) return _internal_variable_set_stmt(); } inline ::pg_query::VariableSetStmt* Node::unsafe_arena_release_variable_set_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.variable_set_stmt) if (_internal_has_variable_set_stmt()) { clear_has_node(); ::pg_query::VariableSetStmt* temp = _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* variable_set_stmt) { clear_node(); if (variable_set_stmt) { set_has_variable_set_stmt(); _impl_.node_.variable_set_stmt_ = variable_set_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.variable_set_stmt) } inline ::pg_query::VariableSetStmt* Node::_internal_mutable_variable_set_stmt() { if (!_internal_has_variable_set_stmt()) { clear_node(); set_has_variable_set_stmt(); _impl_.node_.variable_set_stmt_ = CreateMaybeMessage< ::pg_query::VariableSetStmt >(GetArenaForAllocation()); } return _impl_.node_.variable_set_stmt_; } inline ::pg_query::VariableSetStmt* Node::mutable_variable_set_stmt() { ::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 = 98 [json_name = "VariableShowStmt"]; inline bool Node::_internal_has_variable_show_stmt() const { return node_case() == kVariableShowStmt; } inline bool Node::has_variable_show_stmt() const { return _internal_has_variable_show_stmt(); } inline void Node::set_has_variable_show_stmt() { _impl_._oneof_case_[0] = kVariableShowStmt; } inline void Node::clear_variable_show_stmt() { if (_internal_has_variable_show_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_variable_show_stmt()) { clear_has_node(); ::pg_query::VariableShowStmt* temp = _impl_.node_.variable_show_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_variable_show_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.variable_show_stmt) return _internal_variable_show_stmt(); } inline ::pg_query::VariableShowStmt* Node::unsafe_arena_release_variable_show_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.variable_show_stmt) if (_internal_has_variable_show_stmt()) { clear_has_node(); ::pg_query::VariableShowStmt* temp = _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* variable_show_stmt) { clear_node(); if (variable_show_stmt) { set_has_variable_show_stmt(); _impl_.node_.variable_show_stmt_ = variable_show_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.variable_show_stmt) } inline ::pg_query::VariableShowStmt* Node::_internal_mutable_variable_show_stmt() { if (!_internal_has_variable_show_stmt()) { clear_node(); set_has_variable_show_stmt(); _impl_.node_.variable_show_stmt_ = CreateMaybeMessage< ::pg_query::VariableShowStmt >(GetArenaForAllocation()); } return _impl_.node_.variable_show_stmt_; } inline ::pg_query::VariableShowStmt* Node::mutable_variable_show_stmt() { ::pg_query::VariableShowStmt* _msg = _internal_mutable_variable_show_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.variable_show_stmt) return _msg; } // .pg_query.DiscardStmt discard_stmt = 99 [json_name = "DiscardStmt"]; inline bool Node::_internal_has_discard_stmt() const { return node_case() == kDiscardStmt; } inline bool Node::has_discard_stmt() const { return _internal_has_discard_stmt(); } inline void Node::set_has_discard_stmt() { _impl_._oneof_case_[0] = kDiscardStmt; } inline void Node::clear_discard_stmt() { if (_internal_has_discard_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_discard_stmt()) { clear_has_node(); ::pg_query::DiscardStmt* temp = _impl_.node_.discard_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.discard_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::DiscardStmt& Node::_internal_discard_stmt() const { return _internal_has_discard_stmt() ? *_impl_.node_.discard_stmt_ : reinterpret_cast< ::pg_query::DiscardStmt&>(::pg_query::_DiscardStmt_default_instance_); } inline const ::pg_query::DiscardStmt& Node::discard_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.discard_stmt) return _internal_discard_stmt(); } inline ::pg_query::DiscardStmt* Node::unsafe_arena_release_discard_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.discard_stmt) if (_internal_has_discard_stmt()) { clear_has_node(); ::pg_query::DiscardStmt* temp = _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* discard_stmt) { clear_node(); if (discard_stmt) { set_has_discard_stmt(); _impl_.node_.discard_stmt_ = discard_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.discard_stmt) } inline ::pg_query::DiscardStmt* Node::_internal_mutable_discard_stmt() { if (!_internal_has_discard_stmt()) { clear_node(); set_has_discard_stmt(); _impl_.node_.discard_stmt_ = CreateMaybeMessage< ::pg_query::DiscardStmt >(GetArenaForAllocation()); } return _impl_.node_.discard_stmt_; } inline ::pg_query::DiscardStmt* Node::mutable_discard_stmt() { ::pg_query::DiscardStmt* _msg = _internal_mutable_discard_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.discard_stmt) return _msg; } // .pg_query.CreateTrigStmt create_trig_stmt = 100 [json_name = "CreateTrigStmt"]; inline bool Node::_internal_has_create_trig_stmt() const { return node_case() == kCreateTrigStmt; } inline bool Node::has_create_trig_stmt() const { return _internal_has_create_trig_stmt(); } inline void Node::set_has_create_trig_stmt() { _impl_._oneof_case_[0] = kCreateTrigStmt; } inline void Node::clear_create_trig_stmt() { if (_internal_has_create_trig_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_create_trig_stmt()) { clear_has_node(); ::pg_query::CreateTrigStmt* temp = _impl_.node_.create_trig_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_create_trig_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.create_trig_stmt) return _internal_create_trig_stmt(); } inline ::pg_query::CreateTrigStmt* Node::unsafe_arena_release_create_trig_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_trig_stmt) if (_internal_has_create_trig_stmt()) { clear_has_node(); ::pg_query::CreateTrigStmt* temp = _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* create_trig_stmt) { clear_node(); if (create_trig_stmt) { set_has_create_trig_stmt(); _impl_.node_.create_trig_stmt_ = create_trig_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_trig_stmt) } inline ::pg_query::CreateTrigStmt* Node::_internal_mutable_create_trig_stmt() { if (!_internal_has_create_trig_stmt()) { clear_node(); set_has_create_trig_stmt(); _impl_.node_.create_trig_stmt_ = CreateMaybeMessage< ::pg_query::CreateTrigStmt >(GetArenaForAllocation()); } return _impl_.node_.create_trig_stmt_; } inline ::pg_query::CreateTrigStmt* Node::mutable_create_trig_stmt() { ::pg_query::CreateTrigStmt* _msg = _internal_mutable_create_trig_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.create_trig_stmt) return _msg; } // .pg_query.CreatePLangStmt create_plang_stmt = 101 [json_name = "CreatePLangStmt"]; inline bool Node::_internal_has_create_plang_stmt() const { return node_case() == kCreatePlangStmt; } inline bool Node::has_create_plang_stmt() const { return _internal_has_create_plang_stmt(); } inline void Node::set_has_create_plang_stmt() { _impl_._oneof_case_[0] = kCreatePlangStmt; } inline void Node::clear_create_plang_stmt() { if (_internal_has_create_plang_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_create_plang_stmt()) { clear_has_node(); ::pg_query::CreatePLangStmt* temp = _impl_.node_.create_plang_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_create_plang_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.create_plang_stmt) return _internal_create_plang_stmt(); } inline ::pg_query::CreatePLangStmt* Node::unsafe_arena_release_create_plang_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_plang_stmt) if (_internal_has_create_plang_stmt()) { clear_has_node(); ::pg_query::CreatePLangStmt* temp = _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* create_plang_stmt) { clear_node(); if (create_plang_stmt) { set_has_create_plang_stmt(); _impl_.node_.create_plang_stmt_ = create_plang_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_plang_stmt) } inline ::pg_query::CreatePLangStmt* Node::_internal_mutable_create_plang_stmt() { if (!_internal_has_create_plang_stmt()) { clear_node(); set_has_create_plang_stmt(); _impl_.node_.create_plang_stmt_ = CreateMaybeMessage< ::pg_query::CreatePLangStmt >(GetArenaForAllocation()); } return _impl_.node_.create_plang_stmt_; } inline ::pg_query::CreatePLangStmt* Node::mutable_create_plang_stmt() { ::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 = 102 [json_name = "CreateRoleStmt"]; inline bool Node::_internal_has_create_role_stmt() const { return node_case() == kCreateRoleStmt; } inline bool Node::has_create_role_stmt() const { return _internal_has_create_role_stmt(); } inline void Node::set_has_create_role_stmt() { _impl_._oneof_case_[0] = kCreateRoleStmt; } inline void Node::clear_create_role_stmt() { if (_internal_has_create_role_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_create_role_stmt()) { clear_has_node(); ::pg_query::CreateRoleStmt* temp = _impl_.node_.create_role_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_create_role_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.create_role_stmt) return _internal_create_role_stmt(); } inline ::pg_query::CreateRoleStmt* Node::unsafe_arena_release_create_role_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_role_stmt) if (_internal_has_create_role_stmt()) { clear_has_node(); ::pg_query::CreateRoleStmt* temp = _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* create_role_stmt) { clear_node(); if (create_role_stmt) { set_has_create_role_stmt(); _impl_.node_.create_role_stmt_ = create_role_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_role_stmt) } inline ::pg_query::CreateRoleStmt* Node::_internal_mutable_create_role_stmt() { if (!_internal_has_create_role_stmt()) { clear_node(); set_has_create_role_stmt(); _impl_.node_.create_role_stmt_ = CreateMaybeMessage< ::pg_query::CreateRoleStmt >(GetArenaForAllocation()); } return _impl_.node_.create_role_stmt_; } inline ::pg_query::CreateRoleStmt* Node::mutable_create_role_stmt() { ::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 = 103 [json_name = "AlterRoleStmt"]; inline bool Node::_internal_has_alter_role_stmt() const { return node_case() == kAlterRoleStmt; } inline bool Node::has_alter_role_stmt() const { return _internal_has_alter_role_stmt(); } inline void Node::set_has_alter_role_stmt() { _impl_._oneof_case_[0] = kAlterRoleStmt; } inline void Node::clear_alter_role_stmt() { if (_internal_has_alter_role_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_role_stmt()) { clear_has_node(); ::pg_query::AlterRoleStmt* temp = _impl_.node_.alter_role_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_role_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_role_stmt) return _internal_alter_role_stmt(); } inline ::pg_query::AlterRoleStmt* Node::unsafe_arena_release_alter_role_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_role_stmt) if (_internal_has_alter_role_stmt()) { clear_has_node(); ::pg_query::AlterRoleStmt* temp = _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* alter_role_stmt) { clear_node(); if (alter_role_stmt) { set_has_alter_role_stmt(); _impl_.node_.alter_role_stmt_ = alter_role_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_role_stmt) } inline ::pg_query::AlterRoleStmt* Node::_internal_mutable_alter_role_stmt() { if (!_internal_has_alter_role_stmt()) { clear_node(); set_has_alter_role_stmt(); _impl_.node_.alter_role_stmt_ = CreateMaybeMessage< ::pg_query::AlterRoleStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_role_stmt_; } inline ::pg_query::AlterRoleStmt* Node::mutable_alter_role_stmt() { ::pg_query::AlterRoleStmt* _msg = _internal_mutable_alter_role_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_role_stmt) return _msg; } // .pg_query.DropRoleStmt drop_role_stmt = 104 [json_name = "DropRoleStmt"]; inline bool Node::_internal_has_drop_role_stmt() const { return node_case() == kDropRoleStmt; } inline bool Node::has_drop_role_stmt() const { return _internal_has_drop_role_stmt(); } inline void Node::set_has_drop_role_stmt() { _impl_._oneof_case_[0] = kDropRoleStmt; } inline void Node::clear_drop_role_stmt() { if (_internal_has_drop_role_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_drop_role_stmt()) { clear_has_node(); ::pg_query::DropRoleStmt* temp = _impl_.node_.drop_role_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_drop_role_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.drop_role_stmt) return _internal_drop_role_stmt(); } inline ::pg_query::DropRoleStmt* Node::unsafe_arena_release_drop_role_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.drop_role_stmt) if (_internal_has_drop_role_stmt()) { clear_has_node(); ::pg_query::DropRoleStmt* temp = _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* drop_role_stmt) { clear_node(); if (drop_role_stmt) { set_has_drop_role_stmt(); _impl_.node_.drop_role_stmt_ = drop_role_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.drop_role_stmt) } inline ::pg_query::DropRoleStmt* Node::_internal_mutable_drop_role_stmt() { if (!_internal_has_drop_role_stmt()) { clear_node(); set_has_drop_role_stmt(); _impl_.node_.drop_role_stmt_ = CreateMaybeMessage< ::pg_query::DropRoleStmt >(GetArenaForAllocation()); } return _impl_.node_.drop_role_stmt_; } inline ::pg_query::DropRoleStmt* Node::mutable_drop_role_stmt() { ::pg_query::DropRoleStmt* _msg = _internal_mutable_drop_role_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.drop_role_stmt) return _msg; } // .pg_query.LockStmt lock_stmt = 105 [json_name = "LockStmt"]; inline bool Node::_internal_has_lock_stmt() const { return node_case() == kLockStmt; } inline bool Node::has_lock_stmt() const { return _internal_has_lock_stmt(); } inline void Node::set_has_lock_stmt() { _impl_._oneof_case_[0] = kLockStmt; } inline void Node::clear_lock_stmt() { if (_internal_has_lock_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_lock_stmt()) { clear_has_node(); ::pg_query::LockStmt* temp = _impl_.node_.lock_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.lock_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::LockStmt& Node::_internal_lock_stmt() const { return _internal_has_lock_stmt() ? *_impl_.node_.lock_stmt_ : reinterpret_cast< ::pg_query::LockStmt&>(::pg_query::_LockStmt_default_instance_); } inline const ::pg_query::LockStmt& Node::lock_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.lock_stmt) return _internal_lock_stmt(); } inline ::pg_query::LockStmt* Node::unsafe_arena_release_lock_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.lock_stmt) if (_internal_has_lock_stmt()) { clear_has_node(); ::pg_query::LockStmt* temp = _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* lock_stmt) { clear_node(); if (lock_stmt) { set_has_lock_stmt(); _impl_.node_.lock_stmt_ = lock_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.lock_stmt) } inline ::pg_query::LockStmt* Node::_internal_mutable_lock_stmt() { if (!_internal_has_lock_stmt()) { clear_node(); set_has_lock_stmt(); _impl_.node_.lock_stmt_ = CreateMaybeMessage< ::pg_query::LockStmt >(GetArenaForAllocation()); } return _impl_.node_.lock_stmt_; } inline ::pg_query::LockStmt* Node::mutable_lock_stmt() { ::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 = 106 [json_name = "ConstraintsSetStmt"]; inline bool Node::_internal_has_constraints_set_stmt() const { return node_case() == kConstraintsSetStmt; } inline bool Node::has_constraints_set_stmt() const { return _internal_has_constraints_set_stmt(); } inline void Node::set_has_constraints_set_stmt() { _impl_._oneof_case_[0] = kConstraintsSetStmt; } inline void Node::clear_constraints_set_stmt() { if (_internal_has_constraints_set_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_constraints_set_stmt()) { clear_has_node(); ::pg_query::ConstraintsSetStmt* temp = _impl_.node_.constraints_set_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_constraints_set_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.constraints_set_stmt) return _internal_constraints_set_stmt(); } inline ::pg_query::ConstraintsSetStmt* Node::unsafe_arena_release_constraints_set_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.constraints_set_stmt) if (_internal_has_constraints_set_stmt()) { clear_has_node(); ::pg_query::ConstraintsSetStmt* temp = _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* constraints_set_stmt) { clear_node(); if (constraints_set_stmt) { set_has_constraints_set_stmt(); _impl_.node_.constraints_set_stmt_ = constraints_set_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.constraints_set_stmt) } inline ::pg_query::ConstraintsSetStmt* Node::_internal_mutable_constraints_set_stmt() { if (!_internal_has_constraints_set_stmt()) { clear_node(); set_has_constraints_set_stmt(); _impl_.node_.constraints_set_stmt_ = CreateMaybeMessage< ::pg_query::ConstraintsSetStmt >(GetArenaForAllocation()); } return _impl_.node_.constraints_set_stmt_; } inline ::pg_query::ConstraintsSetStmt* Node::mutable_constraints_set_stmt() { ::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 = 107 [json_name = "ReindexStmt"]; inline bool Node::_internal_has_reindex_stmt() const { return node_case() == kReindexStmt; } inline bool Node::has_reindex_stmt() const { return _internal_has_reindex_stmt(); } inline void Node::set_has_reindex_stmt() { _impl_._oneof_case_[0] = kReindexStmt; } inline void Node::clear_reindex_stmt() { if (_internal_has_reindex_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_reindex_stmt()) { clear_has_node(); ::pg_query::ReindexStmt* temp = _impl_.node_.reindex_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.reindex_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::ReindexStmt& Node::_internal_reindex_stmt() const { return _internal_has_reindex_stmt() ? *_impl_.node_.reindex_stmt_ : reinterpret_cast< ::pg_query::ReindexStmt&>(::pg_query::_ReindexStmt_default_instance_); } inline const ::pg_query::ReindexStmt& Node::reindex_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.reindex_stmt) return _internal_reindex_stmt(); } inline ::pg_query::ReindexStmt* Node::unsafe_arena_release_reindex_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.reindex_stmt) if (_internal_has_reindex_stmt()) { clear_has_node(); ::pg_query::ReindexStmt* temp = _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* reindex_stmt) { clear_node(); if (reindex_stmt) { set_has_reindex_stmt(); _impl_.node_.reindex_stmt_ = reindex_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.reindex_stmt) } inline ::pg_query::ReindexStmt* Node::_internal_mutable_reindex_stmt() { if (!_internal_has_reindex_stmt()) { clear_node(); set_has_reindex_stmt(); _impl_.node_.reindex_stmt_ = CreateMaybeMessage< ::pg_query::ReindexStmt >(GetArenaForAllocation()); } return _impl_.node_.reindex_stmt_; } inline ::pg_query::ReindexStmt* Node::mutable_reindex_stmt() { ::pg_query::ReindexStmt* _msg = _internal_mutable_reindex_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.reindex_stmt) return _msg; } // .pg_query.CheckPointStmt check_point_stmt = 108 [json_name = "CheckPointStmt"]; inline bool Node::_internal_has_check_point_stmt() const { return node_case() == kCheckPointStmt; } inline bool Node::has_check_point_stmt() const { return _internal_has_check_point_stmt(); } inline void Node::set_has_check_point_stmt() { _impl_._oneof_case_[0] = kCheckPointStmt; } inline void Node::clear_check_point_stmt() { if (_internal_has_check_point_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_check_point_stmt()) { clear_has_node(); ::pg_query::CheckPointStmt* temp = _impl_.node_.check_point_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_check_point_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.check_point_stmt) return _internal_check_point_stmt(); } inline ::pg_query::CheckPointStmt* Node::unsafe_arena_release_check_point_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.check_point_stmt) if (_internal_has_check_point_stmt()) { clear_has_node(); ::pg_query::CheckPointStmt* temp = _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* check_point_stmt) { clear_node(); if (check_point_stmt) { set_has_check_point_stmt(); _impl_.node_.check_point_stmt_ = check_point_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.check_point_stmt) } inline ::pg_query::CheckPointStmt* Node::_internal_mutable_check_point_stmt() { if (!_internal_has_check_point_stmt()) { clear_node(); set_has_check_point_stmt(); _impl_.node_.check_point_stmt_ = CreateMaybeMessage< ::pg_query::CheckPointStmt >(GetArenaForAllocation()); } return _impl_.node_.check_point_stmt_; } inline ::pg_query::CheckPointStmt* Node::mutable_check_point_stmt() { ::pg_query::CheckPointStmt* _msg = _internal_mutable_check_point_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.check_point_stmt) return _msg; } // .pg_query.CreateSchemaStmt create_schema_stmt = 109 [json_name = "CreateSchemaStmt"]; inline bool Node::_internal_has_create_schema_stmt() const { return node_case() == kCreateSchemaStmt; } inline bool Node::has_create_schema_stmt() const { return _internal_has_create_schema_stmt(); } inline void Node::set_has_create_schema_stmt() { _impl_._oneof_case_[0] = kCreateSchemaStmt; } inline void Node::clear_create_schema_stmt() { if (_internal_has_create_schema_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_create_schema_stmt()) { clear_has_node(); ::pg_query::CreateSchemaStmt* temp = _impl_.node_.create_schema_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_create_schema_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.create_schema_stmt) return _internal_create_schema_stmt(); } inline ::pg_query::CreateSchemaStmt* Node::unsafe_arena_release_create_schema_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_schema_stmt) if (_internal_has_create_schema_stmt()) { clear_has_node(); ::pg_query::CreateSchemaStmt* temp = _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* create_schema_stmt) { clear_node(); if (create_schema_stmt) { set_has_create_schema_stmt(); _impl_.node_.create_schema_stmt_ = create_schema_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_schema_stmt) } inline ::pg_query::CreateSchemaStmt* Node::_internal_mutable_create_schema_stmt() { if (!_internal_has_create_schema_stmt()) { clear_node(); set_has_create_schema_stmt(); _impl_.node_.create_schema_stmt_ = CreateMaybeMessage< ::pg_query::CreateSchemaStmt >(GetArenaForAllocation()); } return _impl_.node_.create_schema_stmt_; } inline ::pg_query::CreateSchemaStmt* Node::mutable_create_schema_stmt() { ::pg_query::CreateSchemaStmt* _msg = _internal_mutable_create_schema_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.create_schema_stmt) return _msg; } // .pg_query.AlterDatabaseStmt alter_database_stmt = 110 [json_name = "AlterDatabaseStmt"]; inline bool Node::_internal_has_alter_database_stmt() const { return node_case() == kAlterDatabaseStmt; } inline bool Node::has_alter_database_stmt() const { return _internal_has_alter_database_stmt(); } inline void Node::set_has_alter_database_stmt() { _impl_._oneof_case_[0] = kAlterDatabaseStmt; } inline void Node::clear_alter_database_stmt() { if (_internal_has_alter_database_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_database_stmt()) { clear_has_node(); ::pg_query::AlterDatabaseStmt* temp = _impl_.node_.alter_database_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_database_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_database_stmt) return _internal_alter_database_stmt(); } inline ::pg_query::AlterDatabaseStmt* Node::unsafe_arena_release_alter_database_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_database_stmt) if (_internal_has_alter_database_stmt()) { clear_has_node(); ::pg_query::AlterDatabaseStmt* temp = _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* alter_database_stmt) { clear_node(); if (alter_database_stmt) { set_has_alter_database_stmt(); _impl_.node_.alter_database_stmt_ = alter_database_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_database_stmt) } inline ::pg_query::AlterDatabaseStmt* Node::_internal_mutable_alter_database_stmt() { if (!_internal_has_alter_database_stmt()) { clear_node(); set_has_alter_database_stmt(); _impl_.node_.alter_database_stmt_ = CreateMaybeMessage< ::pg_query::AlterDatabaseStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_database_stmt_; } inline ::pg_query::AlterDatabaseStmt* Node::mutable_alter_database_stmt() { ::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 = 111 [json_name = "AlterDatabaseRefreshCollStmt"]; inline bool Node::_internal_has_alter_database_refresh_coll_stmt() const { return node_case() == kAlterDatabaseRefreshCollStmt; } inline bool Node::has_alter_database_refresh_coll_stmt() const { return _internal_has_alter_database_refresh_coll_stmt(); } inline void Node::set_has_alter_database_refresh_coll_stmt() { _impl_._oneof_case_[0] = kAlterDatabaseRefreshCollStmt; } inline void Node::clear_alter_database_refresh_coll_stmt() { if (_internal_has_alter_database_refresh_coll_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_database_refresh_coll_stmt()) { clear_has_node(); ::pg_query::AlterDatabaseRefreshCollStmt* temp = _impl_.node_.alter_database_refresh_coll_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_database_refresh_coll_stmt() ? *_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 { // @@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 (_internal_has_alter_database_refresh_coll_stmt()) { clear_has_node(); ::pg_query::AlterDatabaseRefreshCollStmt* 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* alter_database_refresh_coll_stmt) { clear_node(); if (alter_database_refresh_coll_stmt) { set_has_alter_database_refresh_coll_stmt(); _impl_.node_.alter_database_refresh_coll_stmt_ = alter_database_refresh_coll_stmt; } // @@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 (!_internal_has_alter_database_refresh_coll_stmt()) { clear_node(); set_has_alter_database_refresh_coll_stmt(); _impl_.node_.alter_database_refresh_coll_stmt_ = CreateMaybeMessage< ::pg_query::AlterDatabaseRefreshCollStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_database_refresh_coll_stmt_; } inline ::pg_query::AlterDatabaseRefreshCollStmt* Node::mutable_alter_database_refresh_coll_stmt() { ::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 = 112 [json_name = "AlterDatabaseSetStmt"]; inline bool Node::_internal_has_alter_database_set_stmt() const { return node_case() == kAlterDatabaseSetStmt; } inline bool Node::has_alter_database_set_stmt() const { return _internal_has_alter_database_set_stmt(); } inline void Node::set_has_alter_database_set_stmt() { _impl_._oneof_case_[0] = kAlterDatabaseSetStmt; } inline void Node::clear_alter_database_set_stmt() { if (_internal_has_alter_database_set_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_database_set_stmt()) { clear_has_node(); ::pg_query::AlterDatabaseSetStmt* temp = _impl_.node_.alter_database_set_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_database_set_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_database_set_stmt) return _internal_alter_database_set_stmt(); } inline ::pg_query::AlterDatabaseSetStmt* Node::unsafe_arena_release_alter_database_set_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_database_set_stmt) if (_internal_has_alter_database_set_stmt()) { clear_has_node(); ::pg_query::AlterDatabaseSetStmt* temp = _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* alter_database_set_stmt) { clear_node(); if (alter_database_set_stmt) { set_has_alter_database_set_stmt(); _impl_.node_.alter_database_set_stmt_ = alter_database_set_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_database_set_stmt) } inline ::pg_query::AlterDatabaseSetStmt* Node::_internal_mutable_alter_database_set_stmt() { if (!_internal_has_alter_database_set_stmt()) { clear_node(); set_has_alter_database_set_stmt(); _impl_.node_.alter_database_set_stmt_ = CreateMaybeMessage< ::pg_query::AlterDatabaseSetStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_database_set_stmt_; } inline ::pg_query::AlterDatabaseSetStmt* Node::mutable_alter_database_set_stmt() { ::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.AlterRoleSetStmt alter_role_set_stmt = 113 [json_name = "AlterRoleSetStmt"]; inline bool Node::_internal_has_alter_role_set_stmt() const { return node_case() == kAlterRoleSetStmt; } inline bool Node::has_alter_role_set_stmt() const { return _internal_has_alter_role_set_stmt(); } inline void Node::set_has_alter_role_set_stmt() { _impl_._oneof_case_[0] = kAlterRoleSetStmt; } inline void Node::clear_alter_role_set_stmt() { if (_internal_has_alter_role_set_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_role_set_stmt()) { clear_has_node(); ::pg_query::AlterRoleSetStmt* temp = _impl_.node_.alter_role_set_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_role_set_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_role_set_stmt) return _internal_alter_role_set_stmt(); } inline ::pg_query::AlterRoleSetStmt* Node::unsafe_arena_release_alter_role_set_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_role_set_stmt) if (_internal_has_alter_role_set_stmt()) { clear_has_node(); ::pg_query::AlterRoleSetStmt* temp = _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* alter_role_set_stmt) { clear_node(); if (alter_role_set_stmt) { set_has_alter_role_set_stmt(); _impl_.node_.alter_role_set_stmt_ = alter_role_set_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_role_set_stmt) } inline ::pg_query::AlterRoleSetStmt* Node::_internal_mutable_alter_role_set_stmt() { if (!_internal_has_alter_role_set_stmt()) { clear_node(); set_has_alter_role_set_stmt(); _impl_.node_.alter_role_set_stmt_ = CreateMaybeMessage< ::pg_query::AlterRoleSetStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_role_set_stmt_; } inline ::pg_query::AlterRoleSetStmt* Node::mutable_alter_role_set_stmt() { ::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.CreateConversionStmt create_conversion_stmt = 114 [json_name = "CreateConversionStmt"]; inline bool Node::_internal_has_create_conversion_stmt() const { return node_case() == kCreateConversionStmt; } inline bool Node::has_create_conversion_stmt() const { return _internal_has_create_conversion_stmt(); } inline void Node::set_has_create_conversion_stmt() { _impl_._oneof_case_[0] = kCreateConversionStmt; } inline void Node::clear_create_conversion_stmt() { if (_internal_has_create_conversion_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_create_conversion_stmt()) { clear_has_node(); ::pg_query::CreateConversionStmt* temp = _impl_.node_.create_conversion_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_create_conversion_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.create_conversion_stmt) return _internal_create_conversion_stmt(); } inline ::pg_query::CreateConversionStmt* Node::unsafe_arena_release_create_conversion_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_conversion_stmt) if (_internal_has_create_conversion_stmt()) { clear_has_node(); ::pg_query::CreateConversionStmt* temp = _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* create_conversion_stmt) { clear_node(); if (create_conversion_stmt) { set_has_create_conversion_stmt(); _impl_.node_.create_conversion_stmt_ = create_conversion_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_conversion_stmt) } inline ::pg_query::CreateConversionStmt* Node::_internal_mutable_create_conversion_stmt() { if (!_internal_has_create_conversion_stmt()) { clear_node(); set_has_create_conversion_stmt(); _impl_.node_.create_conversion_stmt_ = CreateMaybeMessage< ::pg_query::CreateConversionStmt >(GetArenaForAllocation()); } return _impl_.node_.create_conversion_stmt_; } inline ::pg_query::CreateConversionStmt* Node::mutable_create_conversion_stmt() { ::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 = 115 [json_name = "CreateCastStmt"]; inline bool Node::_internal_has_create_cast_stmt() const { return node_case() == kCreateCastStmt; } inline bool Node::has_create_cast_stmt() const { return _internal_has_create_cast_stmt(); } inline void Node::set_has_create_cast_stmt() { _impl_._oneof_case_[0] = kCreateCastStmt; } inline void Node::clear_create_cast_stmt() { if (_internal_has_create_cast_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_create_cast_stmt()) { clear_has_node(); ::pg_query::CreateCastStmt* temp = _impl_.node_.create_cast_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_create_cast_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.create_cast_stmt) return _internal_create_cast_stmt(); } inline ::pg_query::CreateCastStmt* Node::unsafe_arena_release_create_cast_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_cast_stmt) if (_internal_has_create_cast_stmt()) { clear_has_node(); ::pg_query::CreateCastStmt* temp = _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* create_cast_stmt) { clear_node(); if (create_cast_stmt) { set_has_create_cast_stmt(); _impl_.node_.create_cast_stmt_ = create_cast_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_cast_stmt) } inline ::pg_query::CreateCastStmt* Node::_internal_mutable_create_cast_stmt() { if (!_internal_has_create_cast_stmt()) { clear_node(); set_has_create_cast_stmt(); _impl_.node_.create_cast_stmt_ = CreateMaybeMessage< ::pg_query::CreateCastStmt >(GetArenaForAllocation()); } return _impl_.node_.create_cast_stmt_; } inline ::pg_query::CreateCastStmt* Node::mutable_create_cast_stmt() { ::pg_query::CreateCastStmt* _msg = _internal_mutable_create_cast_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.create_cast_stmt) return _msg; } // .pg_query.CreateOpClassStmt create_op_class_stmt = 116 [json_name = "CreateOpClassStmt"]; inline bool Node::_internal_has_create_op_class_stmt() const { return node_case() == kCreateOpClassStmt; } inline bool Node::has_create_op_class_stmt() const { return _internal_has_create_op_class_stmt(); } inline void Node::set_has_create_op_class_stmt() { _impl_._oneof_case_[0] = kCreateOpClassStmt; } inline void Node::clear_create_op_class_stmt() { if (_internal_has_create_op_class_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_create_op_class_stmt()) { clear_has_node(); ::pg_query::CreateOpClassStmt* temp = _impl_.node_.create_op_class_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_create_op_class_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.create_op_class_stmt) return _internal_create_op_class_stmt(); } inline ::pg_query::CreateOpClassStmt* Node::unsafe_arena_release_create_op_class_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_op_class_stmt) if (_internal_has_create_op_class_stmt()) { clear_has_node(); ::pg_query::CreateOpClassStmt* temp = _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* create_op_class_stmt) { clear_node(); if (create_op_class_stmt) { set_has_create_op_class_stmt(); _impl_.node_.create_op_class_stmt_ = create_op_class_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_op_class_stmt) } inline ::pg_query::CreateOpClassStmt* Node::_internal_mutable_create_op_class_stmt() { if (!_internal_has_create_op_class_stmt()) { clear_node(); set_has_create_op_class_stmt(); _impl_.node_.create_op_class_stmt_ = CreateMaybeMessage< ::pg_query::CreateOpClassStmt >(GetArenaForAllocation()); } return _impl_.node_.create_op_class_stmt_; } inline ::pg_query::CreateOpClassStmt* Node::mutable_create_op_class_stmt() { ::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.CreateOpFamilyStmt create_op_family_stmt = 117 [json_name = "CreateOpFamilyStmt"]; inline bool Node::_internal_has_create_op_family_stmt() const { return node_case() == kCreateOpFamilyStmt; } inline bool Node::has_create_op_family_stmt() const { return _internal_has_create_op_family_stmt(); } inline void Node::set_has_create_op_family_stmt() { _impl_._oneof_case_[0] = kCreateOpFamilyStmt; } inline void Node::clear_create_op_family_stmt() { if (_internal_has_create_op_family_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_create_op_family_stmt()) { clear_has_node(); ::pg_query::CreateOpFamilyStmt* temp = _impl_.node_.create_op_family_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_create_op_family_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.create_op_family_stmt) return _internal_create_op_family_stmt(); } inline ::pg_query::CreateOpFamilyStmt* Node::unsafe_arena_release_create_op_family_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_op_family_stmt) if (_internal_has_create_op_family_stmt()) { clear_has_node(); ::pg_query::CreateOpFamilyStmt* temp = _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* create_op_family_stmt) { clear_node(); if (create_op_family_stmt) { set_has_create_op_family_stmt(); _impl_.node_.create_op_family_stmt_ = create_op_family_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_op_family_stmt) } inline ::pg_query::CreateOpFamilyStmt* Node::_internal_mutable_create_op_family_stmt() { if (!_internal_has_create_op_family_stmt()) { clear_node(); set_has_create_op_family_stmt(); _impl_.node_.create_op_family_stmt_ = CreateMaybeMessage< ::pg_query::CreateOpFamilyStmt >(GetArenaForAllocation()); } return _impl_.node_.create_op_family_stmt_; } inline ::pg_query::CreateOpFamilyStmt* Node::mutable_create_op_family_stmt() { ::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 = 118 [json_name = "AlterOpFamilyStmt"]; inline bool Node::_internal_has_alter_op_family_stmt() const { return node_case() == kAlterOpFamilyStmt; } inline bool Node::has_alter_op_family_stmt() const { return _internal_has_alter_op_family_stmt(); } inline void Node::set_has_alter_op_family_stmt() { _impl_._oneof_case_[0] = kAlterOpFamilyStmt; } inline void Node::clear_alter_op_family_stmt() { if (_internal_has_alter_op_family_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_op_family_stmt()) { clear_has_node(); ::pg_query::AlterOpFamilyStmt* temp = _impl_.node_.alter_op_family_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_op_family_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_op_family_stmt) return _internal_alter_op_family_stmt(); } inline ::pg_query::AlterOpFamilyStmt* Node::unsafe_arena_release_alter_op_family_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_op_family_stmt) if (_internal_has_alter_op_family_stmt()) { clear_has_node(); ::pg_query::AlterOpFamilyStmt* temp = _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* alter_op_family_stmt) { clear_node(); if (alter_op_family_stmt) { set_has_alter_op_family_stmt(); _impl_.node_.alter_op_family_stmt_ = alter_op_family_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_op_family_stmt) } inline ::pg_query::AlterOpFamilyStmt* Node::_internal_mutable_alter_op_family_stmt() { if (!_internal_has_alter_op_family_stmt()) { clear_node(); set_has_alter_op_family_stmt(); _impl_.node_.alter_op_family_stmt_ = CreateMaybeMessage< ::pg_query::AlterOpFamilyStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_op_family_stmt_; } inline ::pg_query::AlterOpFamilyStmt* Node::mutable_alter_op_family_stmt() { ::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.PrepareStmt prepare_stmt = 119 [json_name = "PrepareStmt"]; inline bool Node::_internal_has_prepare_stmt() const { return node_case() == kPrepareStmt; } inline bool Node::has_prepare_stmt() const { return _internal_has_prepare_stmt(); } inline void Node::set_has_prepare_stmt() { _impl_._oneof_case_[0] = kPrepareStmt; } inline void Node::clear_prepare_stmt() { if (_internal_has_prepare_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_prepare_stmt()) { clear_has_node(); ::pg_query::PrepareStmt* temp = _impl_.node_.prepare_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.prepare_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::PrepareStmt& Node::_internal_prepare_stmt() const { return _internal_has_prepare_stmt() ? *_impl_.node_.prepare_stmt_ : reinterpret_cast< ::pg_query::PrepareStmt&>(::pg_query::_PrepareStmt_default_instance_); } inline const ::pg_query::PrepareStmt& Node::prepare_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.prepare_stmt) return _internal_prepare_stmt(); } inline ::pg_query::PrepareStmt* Node::unsafe_arena_release_prepare_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.prepare_stmt) if (_internal_has_prepare_stmt()) { clear_has_node(); ::pg_query::PrepareStmt* temp = _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* prepare_stmt) { clear_node(); if (prepare_stmt) { set_has_prepare_stmt(); _impl_.node_.prepare_stmt_ = prepare_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.prepare_stmt) } inline ::pg_query::PrepareStmt* Node::_internal_mutable_prepare_stmt() { if (!_internal_has_prepare_stmt()) { clear_node(); set_has_prepare_stmt(); _impl_.node_.prepare_stmt_ = CreateMaybeMessage< ::pg_query::PrepareStmt >(GetArenaForAllocation()); } return _impl_.node_.prepare_stmt_; } inline ::pg_query::PrepareStmt* Node::mutable_prepare_stmt() { ::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 = 120 [json_name = "ExecuteStmt"]; inline bool Node::_internal_has_execute_stmt() const { return node_case() == kExecuteStmt; } inline bool Node::has_execute_stmt() const { return _internal_has_execute_stmt(); } inline void Node::set_has_execute_stmt() { _impl_._oneof_case_[0] = kExecuteStmt; } inline void Node::clear_execute_stmt() { if (_internal_has_execute_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_execute_stmt()) { clear_has_node(); ::pg_query::ExecuteStmt* temp = _impl_.node_.execute_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.execute_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::ExecuteStmt& Node::_internal_execute_stmt() const { return _internal_has_execute_stmt() ? *_impl_.node_.execute_stmt_ : reinterpret_cast< ::pg_query::ExecuteStmt&>(::pg_query::_ExecuteStmt_default_instance_); } inline const ::pg_query::ExecuteStmt& Node::execute_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.execute_stmt) return _internal_execute_stmt(); } inline ::pg_query::ExecuteStmt* Node::unsafe_arena_release_execute_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.execute_stmt) if (_internal_has_execute_stmt()) { clear_has_node(); ::pg_query::ExecuteStmt* temp = _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* execute_stmt) { clear_node(); if (execute_stmt) { set_has_execute_stmt(); _impl_.node_.execute_stmt_ = execute_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.execute_stmt) } inline ::pg_query::ExecuteStmt* Node::_internal_mutable_execute_stmt() { if (!_internal_has_execute_stmt()) { clear_node(); set_has_execute_stmt(); _impl_.node_.execute_stmt_ = CreateMaybeMessage< ::pg_query::ExecuteStmt >(GetArenaForAllocation()); } return _impl_.node_.execute_stmt_; } inline ::pg_query::ExecuteStmt* Node::mutable_execute_stmt() { ::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 = 121 [json_name = "DeallocateStmt"]; inline bool Node::_internal_has_deallocate_stmt() const { return node_case() == kDeallocateStmt; } inline bool Node::has_deallocate_stmt() const { return _internal_has_deallocate_stmt(); } inline void Node::set_has_deallocate_stmt() { _impl_._oneof_case_[0] = kDeallocateStmt; } inline void Node::clear_deallocate_stmt() { if (_internal_has_deallocate_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_deallocate_stmt()) { clear_has_node(); ::pg_query::DeallocateStmt* temp = _impl_.node_.deallocate_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.deallocate_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::DeallocateStmt& Node::_internal_deallocate_stmt() const { return _internal_has_deallocate_stmt() ? *_impl_.node_.deallocate_stmt_ : reinterpret_cast< ::pg_query::DeallocateStmt&>(::pg_query::_DeallocateStmt_default_instance_); } inline const ::pg_query::DeallocateStmt& Node::deallocate_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.deallocate_stmt) return _internal_deallocate_stmt(); } inline ::pg_query::DeallocateStmt* Node::unsafe_arena_release_deallocate_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.deallocate_stmt) if (_internal_has_deallocate_stmt()) { clear_has_node(); ::pg_query::DeallocateStmt* temp = _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* deallocate_stmt) { clear_node(); if (deallocate_stmt) { set_has_deallocate_stmt(); _impl_.node_.deallocate_stmt_ = deallocate_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.deallocate_stmt) } inline ::pg_query::DeallocateStmt* Node::_internal_mutable_deallocate_stmt() { if (!_internal_has_deallocate_stmt()) { clear_node(); set_has_deallocate_stmt(); _impl_.node_.deallocate_stmt_ = CreateMaybeMessage< ::pg_query::DeallocateStmt >(GetArenaForAllocation()); } return _impl_.node_.deallocate_stmt_; } inline ::pg_query::DeallocateStmt* Node::mutable_deallocate_stmt() { ::pg_query::DeallocateStmt* _msg = _internal_mutable_deallocate_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.deallocate_stmt) return _msg; } // .pg_query.DeclareCursorStmt declare_cursor_stmt = 122 [json_name = "DeclareCursorStmt"]; inline bool Node::_internal_has_declare_cursor_stmt() const { return node_case() == kDeclareCursorStmt; } inline bool Node::has_declare_cursor_stmt() const { return _internal_has_declare_cursor_stmt(); } inline void Node::set_has_declare_cursor_stmt() { _impl_._oneof_case_[0] = kDeclareCursorStmt; } inline void Node::clear_declare_cursor_stmt() { if (_internal_has_declare_cursor_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_declare_cursor_stmt()) { clear_has_node(); ::pg_query::DeclareCursorStmt* temp = _impl_.node_.declare_cursor_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_declare_cursor_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.declare_cursor_stmt) return _internal_declare_cursor_stmt(); } inline ::pg_query::DeclareCursorStmt* Node::unsafe_arena_release_declare_cursor_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.declare_cursor_stmt) if (_internal_has_declare_cursor_stmt()) { clear_has_node(); ::pg_query::DeclareCursorStmt* temp = _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* declare_cursor_stmt) { clear_node(); if (declare_cursor_stmt) { set_has_declare_cursor_stmt(); _impl_.node_.declare_cursor_stmt_ = declare_cursor_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.declare_cursor_stmt) } inline ::pg_query::DeclareCursorStmt* Node::_internal_mutable_declare_cursor_stmt() { if (!_internal_has_declare_cursor_stmt()) { clear_node(); set_has_declare_cursor_stmt(); _impl_.node_.declare_cursor_stmt_ = CreateMaybeMessage< ::pg_query::DeclareCursorStmt >(GetArenaForAllocation()); } return _impl_.node_.declare_cursor_stmt_; } inline ::pg_query::DeclareCursorStmt* Node::mutable_declare_cursor_stmt() { ::pg_query::DeclareCursorStmt* _msg = _internal_mutable_declare_cursor_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.declare_cursor_stmt) return _msg; } // .pg_query.CreateTableSpaceStmt create_table_space_stmt = 123 [json_name = "CreateTableSpaceStmt"]; inline bool Node::_internal_has_create_table_space_stmt() const { return node_case() == kCreateTableSpaceStmt; } inline bool Node::has_create_table_space_stmt() const { return _internal_has_create_table_space_stmt(); } inline void Node::set_has_create_table_space_stmt() { _impl_._oneof_case_[0] = kCreateTableSpaceStmt; } inline void Node::clear_create_table_space_stmt() { if (_internal_has_create_table_space_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_create_table_space_stmt()) { clear_has_node(); ::pg_query::CreateTableSpaceStmt* temp = _impl_.node_.create_table_space_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_create_table_space_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.create_table_space_stmt) return _internal_create_table_space_stmt(); } inline ::pg_query::CreateTableSpaceStmt* Node::unsafe_arena_release_create_table_space_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_table_space_stmt) if (_internal_has_create_table_space_stmt()) { clear_has_node(); ::pg_query::CreateTableSpaceStmt* temp = _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* create_table_space_stmt) { clear_node(); if (create_table_space_stmt) { set_has_create_table_space_stmt(); _impl_.node_.create_table_space_stmt_ = create_table_space_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_table_space_stmt) } inline ::pg_query::CreateTableSpaceStmt* Node::_internal_mutable_create_table_space_stmt() { if (!_internal_has_create_table_space_stmt()) { clear_node(); set_has_create_table_space_stmt(); _impl_.node_.create_table_space_stmt_ = CreateMaybeMessage< ::pg_query::CreateTableSpaceStmt >(GetArenaForAllocation()); } return _impl_.node_.create_table_space_stmt_; } inline ::pg_query::CreateTableSpaceStmt* Node::mutable_create_table_space_stmt() { ::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 = 124 [json_name = "DropTableSpaceStmt"]; inline bool Node::_internal_has_drop_table_space_stmt() const { return node_case() == kDropTableSpaceStmt; } inline bool Node::has_drop_table_space_stmt() const { return _internal_has_drop_table_space_stmt(); } inline void Node::set_has_drop_table_space_stmt() { _impl_._oneof_case_[0] = kDropTableSpaceStmt; } inline void Node::clear_drop_table_space_stmt() { if (_internal_has_drop_table_space_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_drop_table_space_stmt()) { clear_has_node(); ::pg_query::DropTableSpaceStmt* temp = _impl_.node_.drop_table_space_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_drop_table_space_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.drop_table_space_stmt) return _internal_drop_table_space_stmt(); } inline ::pg_query::DropTableSpaceStmt* Node::unsafe_arena_release_drop_table_space_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.drop_table_space_stmt) if (_internal_has_drop_table_space_stmt()) { clear_has_node(); ::pg_query::DropTableSpaceStmt* temp = _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* drop_table_space_stmt) { clear_node(); if (drop_table_space_stmt) { set_has_drop_table_space_stmt(); _impl_.node_.drop_table_space_stmt_ = drop_table_space_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.drop_table_space_stmt) } inline ::pg_query::DropTableSpaceStmt* Node::_internal_mutable_drop_table_space_stmt() { if (!_internal_has_drop_table_space_stmt()) { clear_node(); set_has_drop_table_space_stmt(); _impl_.node_.drop_table_space_stmt_ = CreateMaybeMessage< ::pg_query::DropTableSpaceStmt >(GetArenaForAllocation()); } return _impl_.node_.drop_table_space_stmt_; } inline ::pg_query::DropTableSpaceStmt* Node::mutable_drop_table_space_stmt() { ::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.AlterObjectDependsStmt alter_object_depends_stmt = 125 [json_name = "AlterObjectDependsStmt"]; inline bool Node::_internal_has_alter_object_depends_stmt() const { return node_case() == kAlterObjectDependsStmt; } inline bool Node::has_alter_object_depends_stmt() const { return _internal_has_alter_object_depends_stmt(); } inline void Node::set_has_alter_object_depends_stmt() { _impl_._oneof_case_[0] = kAlterObjectDependsStmt; } inline void Node::clear_alter_object_depends_stmt() { if (_internal_has_alter_object_depends_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_object_depends_stmt()) { clear_has_node(); ::pg_query::AlterObjectDependsStmt* temp = _impl_.node_.alter_object_depends_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_object_depends_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_object_depends_stmt) return _internal_alter_object_depends_stmt(); } inline ::pg_query::AlterObjectDependsStmt* Node::unsafe_arena_release_alter_object_depends_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_object_depends_stmt) if (_internal_has_alter_object_depends_stmt()) { clear_has_node(); ::pg_query::AlterObjectDependsStmt* temp = _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* alter_object_depends_stmt) { clear_node(); if (alter_object_depends_stmt) { set_has_alter_object_depends_stmt(); _impl_.node_.alter_object_depends_stmt_ = alter_object_depends_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_object_depends_stmt) } inline ::pg_query::AlterObjectDependsStmt* Node::_internal_mutable_alter_object_depends_stmt() { if (!_internal_has_alter_object_depends_stmt()) { clear_node(); set_has_alter_object_depends_stmt(); _impl_.node_.alter_object_depends_stmt_ = CreateMaybeMessage< ::pg_query::AlterObjectDependsStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_object_depends_stmt_; } inline ::pg_query::AlterObjectDependsStmt* Node::mutable_alter_object_depends_stmt() { ::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 = 126 [json_name = "AlterObjectSchemaStmt"]; inline bool Node::_internal_has_alter_object_schema_stmt() const { return node_case() == kAlterObjectSchemaStmt; } inline bool Node::has_alter_object_schema_stmt() const { return _internal_has_alter_object_schema_stmt(); } inline void Node::set_has_alter_object_schema_stmt() { _impl_._oneof_case_[0] = kAlterObjectSchemaStmt; } inline void Node::clear_alter_object_schema_stmt() { if (_internal_has_alter_object_schema_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_object_schema_stmt()) { clear_has_node(); ::pg_query::AlterObjectSchemaStmt* temp = _impl_.node_.alter_object_schema_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_object_schema_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_object_schema_stmt) return _internal_alter_object_schema_stmt(); } inline ::pg_query::AlterObjectSchemaStmt* Node::unsafe_arena_release_alter_object_schema_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_object_schema_stmt) if (_internal_has_alter_object_schema_stmt()) { clear_has_node(); ::pg_query::AlterObjectSchemaStmt* temp = _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* alter_object_schema_stmt) { clear_node(); if (alter_object_schema_stmt) { set_has_alter_object_schema_stmt(); _impl_.node_.alter_object_schema_stmt_ = alter_object_schema_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_object_schema_stmt) } inline ::pg_query::AlterObjectSchemaStmt* Node::_internal_mutable_alter_object_schema_stmt() { if (!_internal_has_alter_object_schema_stmt()) { clear_node(); set_has_alter_object_schema_stmt(); _impl_.node_.alter_object_schema_stmt_ = CreateMaybeMessage< ::pg_query::AlterObjectSchemaStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_object_schema_stmt_; } inline ::pg_query::AlterObjectSchemaStmt* Node::mutable_alter_object_schema_stmt() { ::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 = 127 [json_name = "AlterOwnerStmt"]; inline bool Node::_internal_has_alter_owner_stmt() const { return node_case() == kAlterOwnerStmt; } inline bool Node::has_alter_owner_stmt() const { return _internal_has_alter_owner_stmt(); } inline void Node::set_has_alter_owner_stmt() { _impl_._oneof_case_[0] = kAlterOwnerStmt; } inline void Node::clear_alter_owner_stmt() { if (_internal_has_alter_owner_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_owner_stmt()) { clear_has_node(); ::pg_query::AlterOwnerStmt* temp = _impl_.node_.alter_owner_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_owner_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_owner_stmt) return _internal_alter_owner_stmt(); } inline ::pg_query::AlterOwnerStmt* Node::unsafe_arena_release_alter_owner_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_owner_stmt) if (_internal_has_alter_owner_stmt()) { clear_has_node(); ::pg_query::AlterOwnerStmt* temp = _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* alter_owner_stmt) { clear_node(); if (alter_owner_stmt) { set_has_alter_owner_stmt(); _impl_.node_.alter_owner_stmt_ = alter_owner_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_owner_stmt) } inline ::pg_query::AlterOwnerStmt* Node::_internal_mutable_alter_owner_stmt() { if (!_internal_has_alter_owner_stmt()) { clear_node(); set_has_alter_owner_stmt(); _impl_.node_.alter_owner_stmt_ = CreateMaybeMessage< ::pg_query::AlterOwnerStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_owner_stmt_; } inline ::pg_query::AlterOwnerStmt* Node::mutable_alter_owner_stmt() { ::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 = 128 [json_name = "AlterOperatorStmt"]; inline bool Node::_internal_has_alter_operator_stmt() const { return node_case() == kAlterOperatorStmt; } inline bool Node::has_alter_operator_stmt() const { return _internal_has_alter_operator_stmt(); } inline void Node::set_has_alter_operator_stmt() { _impl_._oneof_case_[0] = kAlterOperatorStmt; } inline void Node::clear_alter_operator_stmt() { if (_internal_has_alter_operator_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_operator_stmt()) { clear_has_node(); ::pg_query::AlterOperatorStmt* temp = _impl_.node_.alter_operator_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_operator_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_operator_stmt) return _internal_alter_operator_stmt(); } inline ::pg_query::AlterOperatorStmt* Node::unsafe_arena_release_alter_operator_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_operator_stmt) if (_internal_has_alter_operator_stmt()) { clear_has_node(); ::pg_query::AlterOperatorStmt* temp = _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* alter_operator_stmt) { clear_node(); if (alter_operator_stmt) { set_has_alter_operator_stmt(); _impl_.node_.alter_operator_stmt_ = alter_operator_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_operator_stmt) } inline ::pg_query::AlterOperatorStmt* Node::_internal_mutable_alter_operator_stmt() { if (!_internal_has_alter_operator_stmt()) { clear_node(); set_has_alter_operator_stmt(); _impl_.node_.alter_operator_stmt_ = CreateMaybeMessage< ::pg_query::AlterOperatorStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_operator_stmt_; } inline ::pg_query::AlterOperatorStmt* Node::mutable_alter_operator_stmt() { ::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 = 129 [json_name = "AlterTypeStmt"]; inline bool Node::_internal_has_alter_type_stmt() const { return node_case() == kAlterTypeStmt; } inline bool Node::has_alter_type_stmt() const { return _internal_has_alter_type_stmt(); } inline void Node::set_has_alter_type_stmt() { _impl_._oneof_case_[0] = kAlterTypeStmt; } inline void Node::clear_alter_type_stmt() { if (_internal_has_alter_type_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_type_stmt()) { clear_has_node(); ::pg_query::AlterTypeStmt* temp = _impl_.node_.alter_type_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_type_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_type_stmt) return _internal_alter_type_stmt(); } inline ::pg_query::AlterTypeStmt* Node::unsafe_arena_release_alter_type_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_type_stmt) if (_internal_has_alter_type_stmt()) { clear_has_node(); ::pg_query::AlterTypeStmt* temp = _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* alter_type_stmt) { clear_node(); if (alter_type_stmt) { set_has_alter_type_stmt(); _impl_.node_.alter_type_stmt_ = alter_type_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_type_stmt) } inline ::pg_query::AlterTypeStmt* Node::_internal_mutable_alter_type_stmt() { if (!_internal_has_alter_type_stmt()) { clear_node(); set_has_alter_type_stmt(); _impl_.node_.alter_type_stmt_ = CreateMaybeMessage< ::pg_query::AlterTypeStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_type_stmt_; } inline ::pg_query::AlterTypeStmt* Node::mutable_alter_type_stmt() { ::pg_query::AlterTypeStmt* _msg = _internal_mutable_alter_type_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_type_stmt) return _msg; } // .pg_query.DropOwnedStmt drop_owned_stmt = 130 [json_name = "DropOwnedStmt"]; inline bool Node::_internal_has_drop_owned_stmt() const { return node_case() == kDropOwnedStmt; } inline bool Node::has_drop_owned_stmt() const { return _internal_has_drop_owned_stmt(); } inline void Node::set_has_drop_owned_stmt() { _impl_._oneof_case_[0] = kDropOwnedStmt; } inline void Node::clear_drop_owned_stmt() { if (_internal_has_drop_owned_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_drop_owned_stmt()) { clear_has_node(); ::pg_query::DropOwnedStmt* temp = _impl_.node_.drop_owned_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_drop_owned_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.drop_owned_stmt) return _internal_drop_owned_stmt(); } inline ::pg_query::DropOwnedStmt* Node::unsafe_arena_release_drop_owned_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.drop_owned_stmt) if (_internal_has_drop_owned_stmt()) { clear_has_node(); ::pg_query::DropOwnedStmt* temp = _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* drop_owned_stmt) { clear_node(); if (drop_owned_stmt) { set_has_drop_owned_stmt(); _impl_.node_.drop_owned_stmt_ = drop_owned_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.drop_owned_stmt) } inline ::pg_query::DropOwnedStmt* Node::_internal_mutable_drop_owned_stmt() { if (!_internal_has_drop_owned_stmt()) { clear_node(); set_has_drop_owned_stmt(); _impl_.node_.drop_owned_stmt_ = CreateMaybeMessage< ::pg_query::DropOwnedStmt >(GetArenaForAllocation()); } return _impl_.node_.drop_owned_stmt_; } inline ::pg_query::DropOwnedStmt* Node::mutable_drop_owned_stmt() { ::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 = 131 [json_name = "ReassignOwnedStmt"]; inline bool Node::_internal_has_reassign_owned_stmt() const { return node_case() == kReassignOwnedStmt; } inline bool Node::has_reassign_owned_stmt() const { return _internal_has_reassign_owned_stmt(); } inline void Node::set_has_reassign_owned_stmt() { _impl_._oneof_case_[0] = kReassignOwnedStmt; } inline void Node::clear_reassign_owned_stmt() { if (_internal_has_reassign_owned_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_reassign_owned_stmt()) { clear_has_node(); ::pg_query::ReassignOwnedStmt* temp = _impl_.node_.reassign_owned_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_reassign_owned_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.reassign_owned_stmt) return _internal_reassign_owned_stmt(); } inline ::pg_query::ReassignOwnedStmt* Node::unsafe_arena_release_reassign_owned_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.reassign_owned_stmt) if (_internal_has_reassign_owned_stmt()) { clear_has_node(); ::pg_query::ReassignOwnedStmt* temp = _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* reassign_owned_stmt) { clear_node(); if (reassign_owned_stmt) { set_has_reassign_owned_stmt(); _impl_.node_.reassign_owned_stmt_ = reassign_owned_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.reassign_owned_stmt) } inline ::pg_query::ReassignOwnedStmt* Node::_internal_mutable_reassign_owned_stmt() { if (!_internal_has_reassign_owned_stmt()) { clear_node(); set_has_reassign_owned_stmt(); _impl_.node_.reassign_owned_stmt_ = CreateMaybeMessage< ::pg_query::ReassignOwnedStmt >(GetArenaForAllocation()); } return _impl_.node_.reassign_owned_stmt_; } inline ::pg_query::ReassignOwnedStmt* Node::mutable_reassign_owned_stmt() { ::pg_query::ReassignOwnedStmt* _msg = _internal_mutable_reassign_owned_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.reassign_owned_stmt) return _msg; } // .pg_query.CompositeTypeStmt composite_type_stmt = 132 [json_name = "CompositeTypeStmt"]; inline bool Node::_internal_has_composite_type_stmt() const { return node_case() == kCompositeTypeStmt; } inline bool Node::has_composite_type_stmt() const { return _internal_has_composite_type_stmt(); } inline void Node::set_has_composite_type_stmt() { _impl_._oneof_case_[0] = kCompositeTypeStmt; } inline void Node::clear_composite_type_stmt() { if (_internal_has_composite_type_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_composite_type_stmt()) { clear_has_node(); ::pg_query::CompositeTypeStmt* temp = _impl_.node_.composite_type_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_composite_type_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.composite_type_stmt) return _internal_composite_type_stmt(); } inline ::pg_query::CompositeTypeStmt* Node::unsafe_arena_release_composite_type_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.composite_type_stmt) if (_internal_has_composite_type_stmt()) { clear_has_node(); ::pg_query::CompositeTypeStmt* temp = _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* composite_type_stmt) { clear_node(); if (composite_type_stmt) { set_has_composite_type_stmt(); _impl_.node_.composite_type_stmt_ = composite_type_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.composite_type_stmt) } inline ::pg_query::CompositeTypeStmt* Node::_internal_mutable_composite_type_stmt() { if (!_internal_has_composite_type_stmt()) { clear_node(); set_has_composite_type_stmt(); _impl_.node_.composite_type_stmt_ = CreateMaybeMessage< ::pg_query::CompositeTypeStmt >(GetArenaForAllocation()); } return _impl_.node_.composite_type_stmt_; } inline ::pg_query::CompositeTypeStmt* Node::mutable_composite_type_stmt() { ::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 = 133 [json_name = "CreateEnumStmt"]; inline bool Node::_internal_has_create_enum_stmt() const { return node_case() == kCreateEnumStmt; } inline bool Node::has_create_enum_stmt() const { return _internal_has_create_enum_stmt(); } inline void Node::set_has_create_enum_stmt() { _impl_._oneof_case_[0] = kCreateEnumStmt; } inline void Node::clear_create_enum_stmt() { if (_internal_has_create_enum_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_create_enum_stmt()) { clear_has_node(); ::pg_query::CreateEnumStmt* temp = _impl_.node_.create_enum_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_create_enum_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.create_enum_stmt) return _internal_create_enum_stmt(); } inline ::pg_query::CreateEnumStmt* Node::unsafe_arena_release_create_enum_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_enum_stmt) if (_internal_has_create_enum_stmt()) { clear_has_node(); ::pg_query::CreateEnumStmt* temp = _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* create_enum_stmt) { clear_node(); if (create_enum_stmt) { set_has_create_enum_stmt(); _impl_.node_.create_enum_stmt_ = create_enum_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_enum_stmt) } inline ::pg_query::CreateEnumStmt* Node::_internal_mutable_create_enum_stmt() { if (!_internal_has_create_enum_stmt()) { clear_node(); set_has_create_enum_stmt(); _impl_.node_.create_enum_stmt_ = CreateMaybeMessage< ::pg_query::CreateEnumStmt >(GetArenaForAllocation()); } return _impl_.node_.create_enum_stmt_; } inline ::pg_query::CreateEnumStmt* Node::mutable_create_enum_stmt() { ::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 = 134 [json_name = "CreateRangeStmt"]; inline bool Node::_internal_has_create_range_stmt() const { return node_case() == kCreateRangeStmt; } inline bool Node::has_create_range_stmt() const { return _internal_has_create_range_stmt(); } inline void Node::set_has_create_range_stmt() { _impl_._oneof_case_[0] = kCreateRangeStmt; } inline void Node::clear_create_range_stmt() { if (_internal_has_create_range_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_create_range_stmt()) { clear_has_node(); ::pg_query::CreateRangeStmt* temp = _impl_.node_.create_range_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_create_range_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.create_range_stmt) return _internal_create_range_stmt(); } inline ::pg_query::CreateRangeStmt* Node::unsafe_arena_release_create_range_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_range_stmt) if (_internal_has_create_range_stmt()) { clear_has_node(); ::pg_query::CreateRangeStmt* temp = _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* create_range_stmt) { clear_node(); if (create_range_stmt) { set_has_create_range_stmt(); _impl_.node_.create_range_stmt_ = create_range_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_range_stmt) } inline ::pg_query::CreateRangeStmt* Node::_internal_mutable_create_range_stmt() { if (!_internal_has_create_range_stmt()) { clear_node(); set_has_create_range_stmt(); _impl_.node_.create_range_stmt_ = CreateMaybeMessage< ::pg_query::CreateRangeStmt >(GetArenaForAllocation()); } return _impl_.node_.create_range_stmt_; } inline ::pg_query::CreateRangeStmt* Node::mutable_create_range_stmt() { ::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 = 135 [json_name = "AlterEnumStmt"]; inline bool Node::_internal_has_alter_enum_stmt() const { return node_case() == kAlterEnumStmt; } inline bool Node::has_alter_enum_stmt() const { return _internal_has_alter_enum_stmt(); } inline void Node::set_has_alter_enum_stmt() { _impl_._oneof_case_[0] = kAlterEnumStmt; } inline void Node::clear_alter_enum_stmt() { if (_internal_has_alter_enum_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_enum_stmt()) { clear_has_node(); ::pg_query::AlterEnumStmt* temp = _impl_.node_.alter_enum_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_enum_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_enum_stmt) return _internal_alter_enum_stmt(); } inline ::pg_query::AlterEnumStmt* Node::unsafe_arena_release_alter_enum_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_enum_stmt) if (_internal_has_alter_enum_stmt()) { clear_has_node(); ::pg_query::AlterEnumStmt* temp = _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* alter_enum_stmt) { clear_node(); if (alter_enum_stmt) { set_has_alter_enum_stmt(); _impl_.node_.alter_enum_stmt_ = alter_enum_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_enum_stmt) } inline ::pg_query::AlterEnumStmt* Node::_internal_mutable_alter_enum_stmt() { if (!_internal_has_alter_enum_stmt()) { clear_node(); set_has_alter_enum_stmt(); _impl_.node_.alter_enum_stmt_ = CreateMaybeMessage< ::pg_query::AlterEnumStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_enum_stmt_; } inline ::pg_query::AlterEnumStmt* Node::mutable_alter_enum_stmt() { ::pg_query::AlterEnumStmt* _msg = _internal_mutable_alter_enum_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_enum_stmt) return _msg; } // .pg_query.AlterTSDictionaryStmt alter_tsdictionary_stmt = 136 [json_name = "AlterTSDictionaryStmt"]; inline bool Node::_internal_has_alter_tsdictionary_stmt() const { return node_case() == kAlterTsdictionaryStmt; } inline bool Node::has_alter_tsdictionary_stmt() const { return _internal_has_alter_tsdictionary_stmt(); } inline void Node::set_has_alter_tsdictionary_stmt() { _impl_._oneof_case_[0] = kAlterTsdictionaryStmt; } inline void Node::clear_alter_tsdictionary_stmt() { if (_internal_has_alter_tsdictionary_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_tsdictionary_stmt()) { clear_has_node(); ::pg_query::AlterTSDictionaryStmt* temp = _impl_.node_.alter_tsdictionary_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_tsdictionary_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_tsdictionary_stmt) return _internal_alter_tsdictionary_stmt(); } inline ::pg_query::AlterTSDictionaryStmt* Node::unsafe_arena_release_alter_tsdictionary_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_tsdictionary_stmt) if (_internal_has_alter_tsdictionary_stmt()) { clear_has_node(); ::pg_query::AlterTSDictionaryStmt* temp = _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* alter_tsdictionary_stmt) { clear_node(); if (alter_tsdictionary_stmt) { set_has_alter_tsdictionary_stmt(); _impl_.node_.alter_tsdictionary_stmt_ = alter_tsdictionary_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_tsdictionary_stmt) } inline ::pg_query::AlterTSDictionaryStmt* Node::_internal_mutable_alter_tsdictionary_stmt() { if (!_internal_has_alter_tsdictionary_stmt()) { clear_node(); set_has_alter_tsdictionary_stmt(); _impl_.node_.alter_tsdictionary_stmt_ = CreateMaybeMessage< ::pg_query::AlterTSDictionaryStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_tsdictionary_stmt_; } inline ::pg_query::AlterTSDictionaryStmt* Node::mutable_alter_tsdictionary_stmt() { ::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 = 137 [json_name = "AlterTSConfigurationStmt"]; inline bool Node::_internal_has_alter_tsconfiguration_stmt() const { return node_case() == kAlterTsconfigurationStmt; } inline bool Node::has_alter_tsconfiguration_stmt() const { return _internal_has_alter_tsconfiguration_stmt(); } inline void Node::set_has_alter_tsconfiguration_stmt() { _impl_._oneof_case_[0] = kAlterTsconfigurationStmt; } inline void Node::clear_alter_tsconfiguration_stmt() { if (_internal_has_alter_tsconfiguration_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_tsconfiguration_stmt()) { clear_has_node(); ::pg_query::AlterTSConfigurationStmt* temp = _impl_.node_.alter_tsconfiguration_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_tsconfiguration_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_tsconfiguration_stmt) return _internal_alter_tsconfiguration_stmt(); } inline ::pg_query::AlterTSConfigurationStmt* Node::unsafe_arena_release_alter_tsconfiguration_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_tsconfiguration_stmt) if (_internal_has_alter_tsconfiguration_stmt()) { clear_has_node(); ::pg_query::AlterTSConfigurationStmt* temp = _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* alter_tsconfiguration_stmt) { clear_node(); if (alter_tsconfiguration_stmt) { set_has_alter_tsconfiguration_stmt(); _impl_.node_.alter_tsconfiguration_stmt_ = alter_tsconfiguration_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_tsconfiguration_stmt) } inline ::pg_query::AlterTSConfigurationStmt* Node::_internal_mutable_alter_tsconfiguration_stmt() { if (!_internal_has_alter_tsconfiguration_stmt()) { clear_node(); set_has_alter_tsconfiguration_stmt(); _impl_.node_.alter_tsconfiguration_stmt_ = CreateMaybeMessage< ::pg_query::AlterTSConfigurationStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_tsconfiguration_stmt_; } inline ::pg_query::AlterTSConfigurationStmt* Node::mutable_alter_tsconfiguration_stmt() { ::pg_query::AlterTSConfigurationStmt* _msg = _internal_mutable_alter_tsconfiguration_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_tsconfiguration_stmt) return _msg; } // .pg_query.CreateFdwStmt create_fdw_stmt = 138 [json_name = "CreateFdwStmt"]; inline bool Node::_internal_has_create_fdw_stmt() const { return node_case() == kCreateFdwStmt; } inline bool Node::has_create_fdw_stmt() const { return _internal_has_create_fdw_stmt(); } inline void Node::set_has_create_fdw_stmt() { _impl_._oneof_case_[0] = kCreateFdwStmt; } inline void Node::clear_create_fdw_stmt() { if (_internal_has_create_fdw_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_create_fdw_stmt()) { clear_has_node(); ::pg_query::CreateFdwStmt* temp = _impl_.node_.create_fdw_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_create_fdw_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.create_fdw_stmt) return _internal_create_fdw_stmt(); } inline ::pg_query::CreateFdwStmt* Node::unsafe_arena_release_create_fdw_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_fdw_stmt) if (_internal_has_create_fdw_stmt()) { clear_has_node(); ::pg_query::CreateFdwStmt* temp = _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* create_fdw_stmt) { clear_node(); if (create_fdw_stmt) { set_has_create_fdw_stmt(); _impl_.node_.create_fdw_stmt_ = create_fdw_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_fdw_stmt) } inline ::pg_query::CreateFdwStmt* Node::_internal_mutable_create_fdw_stmt() { if (!_internal_has_create_fdw_stmt()) { clear_node(); set_has_create_fdw_stmt(); _impl_.node_.create_fdw_stmt_ = CreateMaybeMessage< ::pg_query::CreateFdwStmt >(GetArenaForAllocation()); } return _impl_.node_.create_fdw_stmt_; } inline ::pg_query::CreateFdwStmt* Node::mutable_create_fdw_stmt() { ::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 = 139 [json_name = "AlterFdwStmt"]; inline bool Node::_internal_has_alter_fdw_stmt() const { return node_case() == kAlterFdwStmt; } inline bool Node::has_alter_fdw_stmt() const { return _internal_has_alter_fdw_stmt(); } inline void Node::set_has_alter_fdw_stmt() { _impl_._oneof_case_[0] = kAlterFdwStmt; } inline void Node::clear_alter_fdw_stmt() { if (_internal_has_alter_fdw_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_fdw_stmt()) { clear_has_node(); ::pg_query::AlterFdwStmt* temp = _impl_.node_.alter_fdw_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_fdw_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_fdw_stmt) return _internal_alter_fdw_stmt(); } inline ::pg_query::AlterFdwStmt* Node::unsafe_arena_release_alter_fdw_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_fdw_stmt) if (_internal_has_alter_fdw_stmt()) { clear_has_node(); ::pg_query::AlterFdwStmt* temp = _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* alter_fdw_stmt) { clear_node(); if (alter_fdw_stmt) { set_has_alter_fdw_stmt(); _impl_.node_.alter_fdw_stmt_ = alter_fdw_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_fdw_stmt) } inline ::pg_query::AlterFdwStmt* Node::_internal_mutable_alter_fdw_stmt() { if (!_internal_has_alter_fdw_stmt()) { clear_node(); set_has_alter_fdw_stmt(); _impl_.node_.alter_fdw_stmt_ = CreateMaybeMessage< ::pg_query::AlterFdwStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_fdw_stmt_; } inline ::pg_query::AlterFdwStmt* Node::mutable_alter_fdw_stmt() { ::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 = 140 [json_name = "CreateForeignServerStmt"]; inline bool Node::_internal_has_create_foreign_server_stmt() const { return node_case() == kCreateForeignServerStmt; } inline bool Node::has_create_foreign_server_stmt() const { return _internal_has_create_foreign_server_stmt(); } inline void Node::set_has_create_foreign_server_stmt() { _impl_._oneof_case_[0] = kCreateForeignServerStmt; } inline void Node::clear_create_foreign_server_stmt() { if (_internal_has_create_foreign_server_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_create_foreign_server_stmt()) { clear_has_node(); ::pg_query::CreateForeignServerStmt* temp = _impl_.node_.create_foreign_server_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_create_foreign_server_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.create_foreign_server_stmt) return _internal_create_foreign_server_stmt(); } inline ::pg_query::CreateForeignServerStmt* Node::unsafe_arena_release_create_foreign_server_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_foreign_server_stmt) if (_internal_has_create_foreign_server_stmt()) { clear_has_node(); ::pg_query::CreateForeignServerStmt* temp = _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* create_foreign_server_stmt) { clear_node(); if (create_foreign_server_stmt) { set_has_create_foreign_server_stmt(); _impl_.node_.create_foreign_server_stmt_ = create_foreign_server_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_foreign_server_stmt) } inline ::pg_query::CreateForeignServerStmt* Node::_internal_mutable_create_foreign_server_stmt() { if (!_internal_has_create_foreign_server_stmt()) { clear_node(); set_has_create_foreign_server_stmt(); _impl_.node_.create_foreign_server_stmt_ = CreateMaybeMessage< ::pg_query::CreateForeignServerStmt >(GetArenaForAllocation()); } return _impl_.node_.create_foreign_server_stmt_; } inline ::pg_query::CreateForeignServerStmt* Node::mutable_create_foreign_server_stmt() { ::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 = 141 [json_name = "AlterForeignServerStmt"]; inline bool Node::_internal_has_alter_foreign_server_stmt() const { return node_case() == kAlterForeignServerStmt; } inline bool Node::has_alter_foreign_server_stmt() const { return _internal_has_alter_foreign_server_stmt(); } inline void Node::set_has_alter_foreign_server_stmt() { _impl_._oneof_case_[0] = kAlterForeignServerStmt; } inline void Node::clear_alter_foreign_server_stmt() { if (_internal_has_alter_foreign_server_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_foreign_server_stmt()) { clear_has_node(); ::pg_query::AlterForeignServerStmt* temp = _impl_.node_.alter_foreign_server_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_foreign_server_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_foreign_server_stmt) return _internal_alter_foreign_server_stmt(); } inline ::pg_query::AlterForeignServerStmt* Node::unsafe_arena_release_alter_foreign_server_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_foreign_server_stmt) if (_internal_has_alter_foreign_server_stmt()) { clear_has_node(); ::pg_query::AlterForeignServerStmt* temp = _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* alter_foreign_server_stmt) { clear_node(); if (alter_foreign_server_stmt) { set_has_alter_foreign_server_stmt(); _impl_.node_.alter_foreign_server_stmt_ = alter_foreign_server_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_foreign_server_stmt) } inline ::pg_query::AlterForeignServerStmt* Node::_internal_mutable_alter_foreign_server_stmt() { if (!_internal_has_alter_foreign_server_stmt()) { clear_node(); set_has_alter_foreign_server_stmt(); _impl_.node_.alter_foreign_server_stmt_ = CreateMaybeMessage< ::pg_query::AlterForeignServerStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_foreign_server_stmt_; } inline ::pg_query::AlterForeignServerStmt* Node::mutable_alter_foreign_server_stmt() { ::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.CreateUserMappingStmt create_user_mapping_stmt = 142 [json_name = "CreateUserMappingStmt"]; inline bool Node::_internal_has_create_user_mapping_stmt() const { return node_case() == kCreateUserMappingStmt; } inline bool Node::has_create_user_mapping_stmt() const { return _internal_has_create_user_mapping_stmt(); } inline void Node::set_has_create_user_mapping_stmt() { _impl_._oneof_case_[0] = kCreateUserMappingStmt; } inline void Node::clear_create_user_mapping_stmt() { if (_internal_has_create_user_mapping_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_create_user_mapping_stmt()) { clear_has_node(); ::pg_query::CreateUserMappingStmt* temp = _impl_.node_.create_user_mapping_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_create_user_mapping_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.create_user_mapping_stmt) return _internal_create_user_mapping_stmt(); } inline ::pg_query::CreateUserMappingStmt* Node::unsafe_arena_release_create_user_mapping_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_user_mapping_stmt) if (_internal_has_create_user_mapping_stmt()) { clear_has_node(); ::pg_query::CreateUserMappingStmt* temp = _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* create_user_mapping_stmt) { clear_node(); if (create_user_mapping_stmt) { set_has_create_user_mapping_stmt(); _impl_.node_.create_user_mapping_stmt_ = create_user_mapping_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_user_mapping_stmt) } inline ::pg_query::CreateUserMappingStmt* Node::_internal_mutable_create_user_mapping_stmt() { if (!_internal_has_create_user_mapping_stmt()) { clear_node(); set_has_create_user_mapping_stmt(); _impl_.node_.create_user_mapping_stmt_ = CreateMaybeMessage< ::pg_query::CreateUserMappingStmt >(GetArenaForAllocation()); } return _impl_.node_.create_user_mapping_stmt_; } inline ::pg_query::CreateUserMappingStmt* Node::mutable_create_user_mapping_stmt() { ::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 = 143 [json_name = "AlterUserMappingStmt"]; inline bool Node::_internal_has_alter_user_mapping_stmt() const { return node_case() == kAlterUserMappingStmt; } inline bool Node::has_alter_user_mapping_stmt() const { return _internal_has_alter_user_mapping_stmt(); } inline void Node::set_has_alter_user_mapping_stmt() { _impl_._oneof_case_[0] = kAlterUserMappingStmt; } inline void Node::clear_alter_user_mapping_stmt() { if (_internal_has_alter_user_mapping_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_user_mapping_stmt()) { clear_has_node(); ::pg_query::AlterUserMappingStmt* temp = _impl_.node_.alter_user_mapping_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_user_mapping_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_user_mapping_stmt) return _internal_alter_user_mapping_stmt(); } inline ::pg_query::AlterUserMappingStmt* Node::unsafe_arena_release_alter_user_mapping_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_user_mapping_stmt) if (_internal_has_alter_user_mapping_stmt()) { clear_has_node(); ::pg_query::AlterUserMappingStmt* temp = _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* alter_user_mapping_stmt) { clear_node(); if (alter_user_mapping_stmt) { set_has_alter_user_mapping_stmt(); _impl_.node_.alter_user_mapping_stmt_ = alter_user_mapping_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_user_mapping_stmt) } inline ::pg_query::AlterUserMappingStmt* Node::_internal_mutable_alter_user_mapping_stmt() { if (!_internal_has_alter_user_mapping_stmt()) { clear_node(); set_has_alter_user_mapping_stmt(); _impl_.node_.alter_user_mapping_stmt_ = CreateMaybeMessage< ::pg_query::AlterUserMappingStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_user_mapping_stmt_; } inline ::pg_query::AlterUserMappingStmt* Node::mutable_alter_user_mapping_stmt() { ::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 = 144 [json_name = "DropUserMappingStmt"]; inline bool Node::_internal_has_drop_user_mapping_stmt() const { return node_case() == kDropUserMappingStmt; } inline bool Node::has_drop_user_mapping_stmt() const { return _internal_has_drop_user_mapping_stmt(); } inline void Node::set_has_drop_user_mapping_stmt() { _impl_._oneof_case_[0] = kDropUserMappingStmt; } inline void Node::clear_drop_user_mapping_stmt() { if (_internal_has_drop_user_mapping_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_drop_user_mapping_stmt()) { clear_has_node(); ::pg_query::DropUserMappingStmt* temp = _impl_.node_.drop_user_mapping_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_drop_user_mapping_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.drop_user_mapping_stmt) return _internal_drop_user_mapping_stmt(); } inline ::pg_query::DropUserMappingStmt* Node::unsafe_arena_release_drop_user_mapping_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.drop_user_mapping_stmt) if (_internal_has_drop_user_mapping_stmt()) { clear_has_node(); ::pg_query::DropUserMappingStmt* temp = _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* drop_user_mapping_stmt) { clear_node(); if (drop_user_mapping_stmt) { set_has_drop_user_mapping_stmt(); _impl_.node_.drop_user_mapping_stmt_ = drop_user_mapping_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.drop_user_mapping_stmt) } inline ::pg_query::DropUserMappingStmt* Node::_internal_mutable_drop_user_mapping_stmt() { if (!_internal_has_drop_user_mapping_stmt()) { clear_node(); set_has_drop_user_mapping_stmt(); _impl_.node_.drop_user_mapping_stmt_ = CreateMaybeMessage< ::pg_query::DropUserMappingStmt >(GetArenaForAllocation()); } return _impl_.node_.drop_user_mapping_stmt_; } inline ::pg_query::DropUserMappingStmt* Node::mutable_drop_user_mapping_stmt() { ::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.AlterTableSpaceOptionsStmt alter_table_space_options_stmt = 145 [json_name = "AlterTableSpaceOptionsStmt"]; inline bool Node::_internal_has_alter_table_space_options_stmt() const { return node_case() == kAlterTableSpaceOptionsStmt; } inline bool Node::has_alter_table_space_options_stmt() const { return _internal_has_alter_table_space_options_stmt(); } inline void Node::set_has_alter_table_space_options_stmt() { _impl_._oneof_case_[0] = kAlterTableSpaceOptionsStmt; } inline void Node::clear_alter_table_space_options_stmt() { if (_internal_has_alter_table_space_options_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_table_space_options_stmt()) { clear_has_node(); ::pg_query::AlterTableSpaceOptionsStmt* temp = _impl_.node_.alter_table_space_options_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_table_space_options_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_table_space_options_stmt) return _internal_alter_table_space_options_stmt(); } inline ::pg_query::AlterTableSpaceOptionsStmt* Node::unsafe_arena_release_alter_table_space_options_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_table_space_options_stmt) if (_internal_has_alter_table_space_options_stmt()) { clear_has_node(); ::pg_query::AlterTableSpaceOptionsStmt* temp = _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* alter_table_space_options_stmt) { clear_node(); if (alter_table_space_options_stmt) { set_has_alter_table_space_options_stmt(); _impl_.node_.alter_table_space_options_stmt_ = alter_table_space_options_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_table_space_options_stmt) } inline ::pg_query::AlterTableSpaceOptionsStmt* Node::_internal_mutable_alter_table_space_options_stmt() { if (!_internal_has_alter_table_space_options_stmt()) { clear_node(); set_has_alter_table_space_options_stmt(); _impl_.node_.alter_table_space_options_stmt_ = CreateMaybeMessage< ::pg_query::AlterTableSpaceOptionsStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_table_space_options_stmt_; } inline ::pg_query::AlterTableSpaceOptionsStmt* Node::mutable_alter_table_space_options_stmt() { ::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 = 146 [json_name = "AlterTableMoveAllStmt"]; inline bool Node::_internal_has_alter_table_move_all_stmt() const { return node_case() == kAlterTableMoveAllStmt; } inline bool Node::has_alter_table_move_all_stmt() const { return _internal_has_alter_table_move_all_stmt(); } inline void Node::set_has_alter_table_move_all_stmt() { _impl_._oneof_case_[0] = kAlterTableMoveAllStmt; } inline void Node::clear_alter_table_move_all_stmt() { if (_internal_has_alter_table_move_all_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_table_move_all_stmt()) { clear_has_node(); ::pg_query::AlterTableMoveAllStmt* temp = _impl_.node_.alter_table_move_all_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_table_move_all_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_table_move_all_stmt) return _internal_alter_table_move_all_stmt(); } inline ::pg_query::AlterTableMoveAllStmt* Node::unsafe_arena_release_alter_table_move_all_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_table_move_all_stmt) if (_internal_has_alter_table_move_all_stmt()) { clear_has_node(); ::pg_query::AlterTableMoveAllStmt* temp = _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* alter_table_move_all_stmt) { clear_node(); if (alter_table_move_all_stmt) { set_has_alter_table_move_all_stmt(); _impl_.node_.alter_table_move_all_stmt_ = alter_table_move_all_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_table_move_all_stmt) } inline ::pg_query::AlterTableMoveAllStmt* Node::_internal_mutable_alter_table_move_all_stmt() { if (!_internal_has_alter_table_move_all_stmt()) { clear_node(); set_has_alter_table_move_all_stmt(); _impl_.node_.alter_table_move_all_stmt_ = CreateMaybeMessage< ::pg_query::AlterTableMoveAllStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_table_move_all_stmt_; } inline ::pg_query::AlterTableMoveAllStmt* Node::mutable_alter_table_move_all_stmt() { ::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.SecLabelStmt sec_label_stmt = 147 [json_name = "SecLabelStmt"]; inline bool Node::_internal_has_sec_label_stmt() const { return node_case() == kSecLabelStmt; } inline bool Node::has_sec_label_stmt() const { return _internal_has_sec_label_stmt(); } inline void Node::set_has_sec_label_stmt() { _impl_._oneof_case_[0] = kSecLabelStmt; } inline void Node::clear_sec_label_stmt() { if (_internal_has_sec_label_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_sec_label_stmt()) { clear_has_node(); ::pg_query::SecLabelStmt* temp = _impl_.node_.sec_label_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_sec_label_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.sec_label_stmt) return _internal_sec_label_stmt(); } inline ::pg_query::SecLabelStmt* Node::unsafe_arena_release_sec_label_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.sec_label_stmt) if (_internal_has_sec_label_stmt()) { clear_has_node(); ::pg_query::SecLabelStmt* temp = _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* sec_label_stmt) { clear_node(); if (sec_label_stmt) { set_has_sec_label_stmt(); _impl_.node_.sec_label_stmt_ = sec_label_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.sec_label_stmt) } inline ::pg_query::SecLabelStmt* Node::_internal_mutable_sec_label_stmt() { if (!_internal_has_sec_label_stmt()) { clear_node(); set_has_sec_label_stmt(); _impl_.node_.sec_label_stmt_ = CreateMaybeMessage< ::pg_query::SecLabelStmt >(GetArenaForAllocation()); } return _impl_.node_.sec_label_stmt_; } inline ::pg_query::SecLabelStmt* Node::mutable_sec_label_stmt() { ::pg_query::SecLabelStmt* _msg = _internal_mutable_sec_label_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.sec_label_stmt) return _msg; } // .pg_query.CreateForeignTableStmt create_foreign_table_stmt = 148 [json_name = "CreateForeignTableStmt"]; inline bool Node::_internal_has_create_foreign_table_stmt() const { return node_case() == kCreateForeignTableStmt; } inline bool Node::has_create_foreign_table_stmt() const { return _internal_has_create_foreign_table_stmt(); } inline void Node::set_has_create_foreign_table_stmt() { _impl_._oneof_case_[0] = kCreateForeignTableStmt; } inline void Node::clear_create_foreign_table_stmt() { if (_internal_has_create_foreign_table_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_create_foreign_table_stmt()) { clear_has_node(); ::pg_query::CreateForeignTableStmt* temp = _impl_.node_.create_foreign_table_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_create_foreign_table_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.create_foreign_table_stmt) return _internal_create_foreign_table_stmt(); } inline ::pg_query::CreateForeignTableStmt* Node::unsafe_arena_release_create_foreign_table_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_foreign_table_stmt) if (_internal_has_create_foreign_table_stmt()) { clear_has_node(); ::pg_query::CreateForeignTableStmt* temp = _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* create_foreign_table_stmt) { clear_node(); if (create_foreign_table_stmt) { set_has_create_foreign_table_stmt(); _impl_.node_.create_foreign_table_stmt_ = create_foreign_table_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_foreign_table_stmt) } inline ::pg_query::CreateForeignTableStmt* Node::_internal_mutable_create_foreign_table_stmt() { if (!_internal_has_create_foreign_table_stmt()) { clear_node(); set_has_create_foreign_table_stmt(); _impl_.node_.create_foreign_table_stmt_ = CreateMaybeMessage< ::pg_query::CreateForeignTableStmt >(GetArenaForAllocation()); } return _impl_.node_.create_foreign_table_stmt_; } inline ::pg_query::CreateForeignTableStmt* Node::mutable_create_foreign_table_stmt() { ::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.ImportForeignSchemaStmt import_foreign_schema_stmt = 149 [json_name = "ImportForeignSchemaStmt"]; inline bool Node::_internal_has_import_foreign_schema_stmt() const { return node_case() == kImportForeignSchemaStmt; } inline bool Node::has_import_foreign_schema_stmt() const { return _internal_has_import_foreign_schema_stmt(); } inline void Node::set_has_import_foreign_schema_stmt() { _impl_._oneof_case_[0] = kImportForeignSchemaStmt; } inline void Node::clear_import_foreign_schema_stmt() { if (_internal_has_import_foreign_schema_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_import_foreign_schema_stmt()) { clear_has_node(); ::pg_query::ImportForeignSchemaStmt* temp = _impl_.node_.import_foreign_schema_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_import_foreign_schema_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.import_foreign_schema_stmt) return _internal_import_foreign_schema_stmt(); } inline ::pg_query::ImportForeignSchemaStmt* Node::unsafe_arena_release_import_foreign_schema_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.import_foreign_schema_stmt) if (_internal_has_import_foreign_schema_stmt()) { clear_has_node(); ::pg_query::ImportForeignSchemaStmt* temp = _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* import_foreign_schema_stmt) { clear_node(); if (import_foreign_schema_stmt) { set_has_import_foreign_schema_stmt(); _impl_.node_.import_foreign_schema_stmt_ = import_foreign_schema_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.import_foreign_schema_stmt) } inline ::pg_query::ImportForeignSchemaStmt* Node::_internal_mutable_import_foreign_schema_stmt() { if (!_internal_has_import_foreign_schema_stmt()) { clear_node(); set_has_import_foreign_schema_stmt(); _impl_.node_.import_foreign_schema_stmt_ = CreateMaybeMessage< ::pg_query::ImportForeignSchemaStmt >(GetArenaForAllocation()); } return _impl_.node_.import_foreign_schema_stmt_; } inline ::pg_query::ImportForeignSchemaStmt* Node::mutable_import_foreign_schema_stmt() { ::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.CreateExtensionStmt create_extension_stmt = 150 [json_name = "CreateExtensionStmt"]; inline bool Node::_internal_has_create_extension_stmt() const { return node_case() == kCreateExtensionStmt; } inline bool Node::has_create_extension_stmt() const { return _internal_has_create_extension_stmt(); } inline void Node::set_has_create_extension_stmt() { _impl_._oneof_case_[0] = kCreateExtensionStmt; } inline void Node::clear_create_extension_stmt() { if (_internal_has_create_extension_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_create_extension_stmt()) { clear_has_node(); ::pg_query::CreateExtensionStmt* temp = _impl_.node_.create_extension_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_create_extension_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.create_extension_stmt) return _internal_create_extension_stmt(); } inline ::pg_query::CreateExtensionStmt* Node::unsafe_arena_release_create_extension_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_extension_stmt) if (_internal_has_create_extension_stmt()) { clear_has_node(); ::pg_query::CreateExtensionStmt* temp = _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* create_extension_stmt) { clear_node(); if (create_extension_stmt) { set_has_create_extension_stmt(); _impl_.node_.create_extension_stmt_ = create_extension_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_extension_stmt) } inline ::pg_query::CreateExtensionStmt* Node::_internal_mutable_create_extension_stmt() { if (!_internal_has_create_extension_stmt()) { clear_node(); set_has_create_extension_stmt(); _impl_.node_.create_extension_stmt_ = CreateMaybeMessage< ::pg_query::CreateExtensionStmt >(GetArenaForAllocation()); } return _impl_.node_.create_extension_stmt_; } inline ::pg_query::CreateExtensionStmt* Node::mutable_create_extension_stmt() { ::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 = 151 [json_name = "AlterExtensionStmt"]; inline bool Node::_internal_has_alter_extension_stmt() const { return node_case() == kAlterExtensionStmt; } inline bool Node::has_alter_extension_stmt() const { return _internal_has_alter_extension_stmt(); } inline void Node::set_has_alter_extension_stmt() { _impl_._oneof_case_[0] = kAlterExtensionStmt; } inline void Node::clear_alter_extension_stmt() { if (_internal_has_alter_extension_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_extension_stmt()) { clear_has_node(); ::pg_query::AlterExtensionStmt* temp = _impl_.node_.alter_extension_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_extension_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_extension_stmt) return _internal_alter_extension_stmt(); } inline ::pg_query::AlterExtensionStmt* Node::unsafe_arena_release_alter_extension_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_extension_stmt) if (_internal_has_alter_extension_stmt()) { clear_has_node(); ::pg_query::AlterExtensionStmt* temp = _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* alter_extension_stmt) { clear_node(); if (alter_extension_stmt) { set_has_alter_extension_stmt(); _impl_.node_.alter_extension_stmt_ = alter_extension_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_extension_stmt) } inline ::pg_query::AlterExtensionStmt* Node::_internal_mutable_alter_extension_stmt() { if (!_internal_has_alter_extension_stmt()) { clear_node(); set_has_alter_extension_stmt(); _impl_.node_.alter_extension_stmt_ = CreateMaybeMessage< ::pg_query::AlterExtensionStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_extension_stmt_; } inline ::pg_query::AlterExtensionStmt* Node::mutable_alter_extension_stmt() { ::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 = 152 [json_name = "AlterExtensionContentsStmt"]; inline bool Node::_internal_has_alter_extension_contents_stmt() const { return node_case() == kAlterExtensionContentsStmt; } inline bool Node::has_alter_extension_contents_stmt() const { return _internal_has_alter_extension_contents_stmt(); } inline void Node::set_has_alter_extension_contents_stmt() { _impl_._oneof_case_[0] = kAlterExtensionContentsStmt; } inline void Node::clear_alter_extension_contents_stmt() { if (_internal_has_alter_extension_contents_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_extension_contents_stmt()) { clear_has_node(); ::pg_query::AlterExtensionContentsStmt* temp = _impl_.node_.alter_extension_contents_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_extension_contents_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_extension_contents_stmt) return _internal_alter_extension_contents_stmt(); } inline ::pg_query::AlterExtensionContentsStmt* Node::unsafe_arena_release_alter_extension_contents_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_extension_contents_stmt) if (_internal_has_alter_extension_contents_stmt()) { clear_has_node(); ::pg_query::AlterExtensionContentsStmt* temp = _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* alter_extension_contents_stmt) { clear_node(); if (alter_extension_contents_stmt) { set_has_alter_extension_contents_stmt(); _impl_.node_.alter_extension_contents_stmt_ = alter_extension_contents_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_extension_contents_stmt) } inline ::pg_query::AlterExtensionContentsStmt* Node::_internal_mutable_alter_extension_contents_stmt() { if (!_internal_has_alter_extension_contents_stmt()) { clear_node(); set_has_alter_extension_contents_stmt(); _impl_.node_.alter_extension_contents_stmt_ = CreateMaybeMessage< ::pg_query::AlterExtensionContentsStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_extension_contents_stmt_; } inline ::pg_query::AlterExtensionContentsStmt* Node::mutable_alter_extension_contents_stmt() { ::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.CreateEventTrigStmt create_event_trig_stmt = 153 [json_name = "CreateEventTrigStmt"]; inline bool Node::_internal_has_create_event_trig_stmt() const { return node_case() == kCreateEventTrigStmt; } inline bool Node::has_create_event_trig_stmt() const { return _internal_has_create_event_trig_stmt(); } inline void Node::set_has_create_event_trig_stmt() { _impl_._oneof_case_[0] = kCreateEventTrigStmt; } inline void Node::clear_create_event_trig_stmt() { if (_internal_has_create_event_trig_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_create_event_trig_stmt()) { clear_has_node(); ::pg_query::CreateEventTrigStmt* temp = _impl_.node_.create_event_trig_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_create_event_trig_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.create_event_trig_stmt) return _internal_create_event_trig_stmt(); } inline ::pg_query::CreateEventTrigStmt* Node::unsafe_arena_release_create_event_trig_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_event_trig_stmt) if (_internal_has_create_event_trig_stmt()) { clear_has_node(); ::pg_query::CreateEventTrigStmt* temp = _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* create_event_trig_stmt) { clear_node(); if (create_event_trig_stmt) { set_has_create_event_trig_stmt(); _impl_.node_.create_event_trig_stmt_ = create_event_trig_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_event_trig_stmt) } inline ::pg_query::CreateEventTrigStmt* Node::_internal_mutable_create_event_trig_stmt() { if (!_internal_has_create_event_trig_stmt()) { clear_node(); set_has_create_event_trig_stmt(); _impl_.node_.create_event_trig_stmt_ = CreateMaybeMessage< ::pg_query::CreateEventTrigStmt >(GetArenaForAllocation()); } return _impl_.node_.create_event_trig_stmt_; } inline ::pg_query::CreateEventTrigStmt* Node::mutable_create_event_trig_stmt() { ::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 = 154 [json_name = "AlterEventTrigStmt"]; inline bool Node::_internal_has_alter_event_trig_stmt() const { return node_case() == kAlterEventTrigStmt; } inline bool Node::has_alter_event_trig_stmt() const { return _internal_has_alter_event_trig_stmt(); } inline void Node::set_has_alter_event_trig_stmt() { _impl_._oneof_case_[0] = kAlterEventTrigStmt; } inline void Node::clear_alter_event_trig_stmt() { if (_internal_has_alter_event_trig_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_event_trig_stmt()) { clear_has_node(); ::pg_query::AlterEventTrigStmt* temp = _impl_.node_.alter_event_trig_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_event_trig_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_event_trig_stmt) return _internal_alter_event_trig_stmt(); } inline ::pg_query::AlterEventTrigStmt* Node::unsafe_arena_release_alter_event_trig_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_event_trig_stmt) if (_internal_has_alter_event_trig_stmt()) { clear_has_node(); ::pg_query::AlterEventTrigStmt* temp = _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* alter_event_trig_stmt) { clear_node(); if (alter_event_trig_stmt) { set_has_alter_event_trig_stmt(); _impl_.node_.alter_event_trig_stmt_ = alter_event_trig_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_event_trig_stmt) } inline ::pg_query::AlterEventTrigStmt* Node::_internal_mutable_alter_event_trig_stmt() { if (!_internal_has_alter_event_trig_stmt()) { clear_node(); set_has_alter_event_trig_stmt(); _impl_.node_.alter_event_trig_stmt_ = CreateMaybeMessage< ::pg_query::AlterEventTrigStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_event_trig_stmt_; } inline ::pg_query::AlterEventTrigStmt* Node::mutable_alter_event_trig_stmt() { ::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.RefreshMatViewStmt refresh_mat_view_stmt = 155 [json_name = "RefreshMatViewStmt"]; inline bool Node::_internal_has_refresh_mat_view_stmt() const { return node_case() == kRefreshMatViewStmt; } inline bool Node::has_refresh_mat_view_stmt() const { return _internal_has_refresh_mat_view_stmt(); } inline void Node::set_has_refresh_mat_view_stmt() { _impl_._oneof_case_[0] = kRefreshMatViewStmt; } inline void Node::clear_refresh_mat_view_stmt() { if (_internal_has_refresh_mat_view_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_refresh_mat_view_stmt()) { clear_has_node(); ::pg_query::RefreshMatViewStmt* temp = _impl_.node_.refresh_mat_view_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_refresh_mat_view_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.refresh_mat_view_stmt) return _internal_refresh_mat_view_stmt(); } inline ::pg_query::RefreshMatViewStmt* Node::unsafe_arena_release_refresh_mat_view_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.refresh_mat_view_stmt) if (_internal_has_refresh_mat_view_stmt()) { clear_has_node(); ::pg_query::RefreshMatViewStmt* temp = _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* refresh_mat_view_stmt) { clear_node(); if (refresh_mat_view_stmt) { set_has_refresh_mat_view_stmt(); _impl_.node_.refresh_mat_view_stmt_ = refresh_mat_view_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.refresh_mat_view_stmt) } inline ::pg_query::RefreshMatViewStmt* Node::_internal_mutable_refresh_mat_view_stmt() { if (!_internal_has_refresh_mat_view_stmt()) { clear_node(); set_has_refresh_mat_view_stmt(); _impl_.node_.refresh_mat_view_stmt_ = CreateMaybeMessage< ::pg_query::RefreshMatViewStmt >(GetArenaForAllocation()); } return _impl_.node_.refresh_mat_view_stmt_; } inline ::pg_query::RefreshMatViewStmt* Node::mutable_refresh_mat_view_stmt() { ::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.ReplicaIdentityStmt replica_identity_stmt = 156 [json_name = "ReplicaIdentityStmt"]; inline bool Node::_internal_has_replica_identity_stmt() const { return node_case() == kReplicaIdentityStmt; } inline bool Node::has_replica_identity_stmt() const { return _internal_has_replica_identity_stmt(); } inline void Node::set_has_replica_identity_stmt() { _impl_._oneof_case_[0] = kReplicaIdentityStmt; } inline void Node::clear_replica_identity_stmt() { if (_internal_has_replica_identity_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_replica_identity_stmt()) { clear_has_node(); ::pg_query::ReplicaIdentityStmt* temp = _impl_.node_.replica_identity_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_replica_identity_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.replica_identity_stmt) return _internal_replica_identity_stmt(); } inline ::pg_query::ReplicaIdentityStmt* Node::unsafe_arena_release_replica_identity_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.replica_identity_stmt) if (_internal_has_replica_identity_stmt()) { clear_has_node(); ::pg_query::ReplicaIdentityStmt* temp = _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* replica_identity_stmt) { clear_node(); if (replica_identity_stmt) { set_has_replica_identity_stmt(); _impl_.node_.replica_identity_stmt_ = replica_identity_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.replica_identity_stmt) } inline ::pg_query::ReplicaIdentityStmt* Node::_internal_mutable_replica_identity_stmt() { if (!_internal_has_replica_identity_stmt()) { clear_node(); set_has_replica_identity_stmt(); _impl_.node_.replica_identity_stmt_ = CreateMaybeMessage< ::pg_query::ReplicaIdentityStmt >(GetArenaForAllocation()); } return _impl_.node_.replica_identity_stmt_; } inline ::pg_query::ReplicaIdentityStmt* Node::mutable_replica_identity_stmt() { ::pg_query::ReplicaIdentityStmt* _msg = _internal_mutable_replica_identity_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.replica_identity_stmt) return _msg; } // .pg_query.AlterSystemStmt alter_system_stmt = 157 [json_name = "AlterSystemStmt"]; inline bool Node::_internal_has_alter_system_stmt() const { return node_case() == kAlterSystemStmt; } inline bool Node::has_alter_system_stmt() const { return _internal_has_alter_system_stmt(); } inline void Node::set_has_alter_system_stmt() { _impl_._oneof_case_[0] = kAlterSystemStmt; } inline void Node::clear_alter_system_stmt() { if (_internal_has_alter_system_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_system_stmt()) { clear_has_node(); ::pg_query::AlterSystemStmt* temp = _impl_.node_.alter_system_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_system_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_system_stmt) return _internal_alter_system_stmt(); } inline ::pg_query::AlterSystemStmt* Node::unsafe_arena_release_alter_system_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_system_stmt) if (_internal_has_alter_system_stmt()) { clear_has_node(); ::pg_query::AlterSystemStmt* temp = _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* alter_system_stmt) { clear_node(); if (alter_system_stmt) { set_has_alter_system_stmt(); _impl_.node_.alter_system_stmt_ = alter_system_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_system_stmt) } inline ::pg_query::AlterSystemStmt* Node::_internal_mutable_alter_system_stmt() { if (!_internal_has_alter_system_stmt()) { clear_node(); set_has_alter_system_stmt(); _impl_.node_.alter_system_stmt_ = CreateMaybeMessage< ::pg_query::AlterSystemStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_system_stmt_; } inline ::pg_query::AlterSystemStmt* Node::mutable_alter_system_stmt() { ::pg_query::AlterSystemStmt* _msg = _internal_mutable_alter_system_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_system_stmt) return _msg; } // .pg_query.CreatePolicyStmt create_policy_stmt = 158 [json_name = "CreatePolicyStmt"]; inline bool Node::_internal_has_create_policy_stmt() const { return node_case() == kCreatePolicyStmt; } inline bool Node::has_create_policy_stmt() const { return _internal_has_create_policy_stmt(); } inline void Node::set_has_create_policy_stmt() { _impl_._oneof_case_[0] = kCreatePolicyStmt; } inline void Node::clear_create_policy_stmt() { if (_internal_has_create_policy_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_create_policy_stmt()) { clear_has_node(); ::pg_query::CreatePolicyStmt* temp = _impl_.node_.create_policy_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_create_policy_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.create_policy_stmt) return _internal_create_policy_stmt(); } inline ::pg_query::CreatePolicyStmt* Node::unsafe_arena_release_create_policy_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_policy_stmt) if (_internal_has_create_policy_stmt()) { clear_has_node(); ::pg_query::CreatePolicyStmt* temp = _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* create_policy_stmt) { clear_node(); if (create_policy_stmt) { set_has_create_policy_stmt(); _impl_.node_.create_policy_stmt_ = create_policy_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_policy_stmt) } inline ::pg_query::CreatePolicyStmt* Node::_internal_mutable_create_policy_stmt() { if (!_internal_has_create_policy_stmt()) { clear_node(); set_has_create_policy_stmt(); _impl_.node_.create_policy_stmt_ = CreateMaybeMessage< ::pg_query::CreatePolicyStmt >(GetArenaForAllocation()); } return _impl_.node_.create_policy_stmt_; } inline ::pg_query::CreatePolicyStmt* Node::mutable_create_policy_stmt() { ::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 = 159 [json_name = "AlterPolicyStmt"]; inline bool Node::_internal_has_alter_policy_stmt() const { return node_case() == kAlterPolicyStmt; } inline bool Node::has_alter_policy_stmt() const { return _internal_has_alter_policy_stmt(); } inline void Node::set_has_alter_policy_stmt() { _impl_._oneof_case_[0] = kAlterPolicyStmt; } inline void Node::clear_alter_policy_stmt() { if (_internal_has_alter_policy_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_policy_stmt()) { clear_has_node(); ::pg_query::AlterPolicyStmt* temp = _impl_.node_.alter_policy_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_policy_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_policy_stmt) return _internal_alter_policy_stmt(); } inline ::pg_query::AlterPolicyStmt* Node::unsafe_arena_release_alter_policy_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_policy_stmt) if (_internal_has_alter_policy_stmt()) { clear_has_node(); ::pg_query::AlterPolicyStmt* temp = _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* alter_policy_stmt) { clear_node(); if (alter_policy_stmt) { set_has_alter_policy_stmt(); _impl_.node_.alter_policy_stmt_ = alter_policy_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_policy_stmt) } inline ::pg_query::AlterPolicyStmt* Node::_internal_mutable_alter_policy_stmt() { if (!_internal_has_alter_policy_stmt()) { clear_node(); set_has_alter_policy_stmt(); _impl_.node_.alter_policy_stmt_ = CreateMaybeMessage< ::pg_query::AlterPolicyStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_policy_stmt_; } inline ::pg_query::AlterPolicyStmt* Node::mutable_alter_policy_stmt() { ::pg_query::AlterPolicyStmt* _msg = _internal_mutable_alter_policy_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_policy_stmt) return _msg; } // .pg_query.CreateTransformStmt create_transform_stmt = 160 [json_name = "CreateTransformStmt"]; inline bool Node::_internal_has_create_transform_stmt() const { return node_case() == kCreateTransformStmt; } inline bool Node::has_create_transform_stmt() const { return _internal_has_create_transform_stmt(); } inline void Node::set_has_create_transform_stmt() { _impl_._oneof_case_[0] = kCreateTransformStmt; } inline void Node::clear_create_transform_stmt() { if (_internal_has_create_transform_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_create_transform_stmt()) { clear_has_node(); ::pg_query::CreateTransformStmt* temp = _impl_.node_.create_transform_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_create_transform_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.create_transform_stmt) return _internal_create_transform_stmt(); } inline ::pg_query::CreateTransformStmt* Node::unsafe_arena_release_create_transform_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_transform_stmt) if (_internal_has_create_transform_stmt()) { clear_has_node(); ::pg_query::CreateTransformStmt* temp = _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* create_transform_stmt) { clear_node(); if (create_transform_stmt) { set_has_create_transform_stmt(); _impl_.node_.create_transform_stmt_ = create_transform_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_transform_stmt) } inline ::pg_query::CreateTransformStmt* Node::_internal_mutable_create_transform_stmt() { if (!_internal_has_create_transform_stmt()) { clear_node(); set_has_create_transform_stmt(); _impl_.node_.create_transform_stmt_ = CreateMaybeMessage< ::pg_query::CreateTransformStmt >(GetArenaForAllocation()); } return _impl_.node_.create_transform_stmt_; } inline ::pg_query::CreateTransformStmt* Node::mutable_create_transform_stmt() { ::pg_query::CreateTransformStmt* _msg = _internal_mutable_create_transform_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.create_transform_stmt) return _msg; } // .pg_query.CreateAmStmt create_am_stmt = 161 [json_name = "CreateAmStmt"]; inline bool Node::_internal_has_create_am_stmt() const { return node_case() == kCreateAmStmt; } inline bool Node::has_create_am_stmt() const { return _internal_has_create_am_stmt(); } inline void Node::set_has_create_am_stmt() { _impl_._oneof_case_[0] = kCreateAmStmt; } inline void Node::clear_create_am_stmt() { if (_internal_has_create_am_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_create_am_stmt()) { clear_has_node(); ::pg_query::CreateAmStmt* temp = _impl_.node_.create_am_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_create_am_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.create_am_stmt) return _internal_create_am_stmt(); } inline ::pg_query::CreateAmStmt* Node::unsafe_arena_release_create_am_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_am_stmt) if (_internal_has_create_am_stmt()) { clear_has_node(); ::pg_query::CreateAmStmt* temp = _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* create_am_stmt) { clear_node(); if (create_am_stmt) { set_has_create_am_stmt(); _impl_.node_.create_am_stmt_ = create_am_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_am_stmt) } inline ::pg_query::CreateAmStmt* Node::_internal_mutable_create_am_stmt() { if (!_internal_has_create_am_stmt()) { clear_node(); set_has_create_am_stmt(); _impl_.node_.create_am_stmt_ = CreateMaybeMessage< ::pg_query::CreateAmStmt >(GetArenaForAllocation()); } return _impl_.node_.create_am_stmt_; } inline ::pg_query::CreateAmStmt* Node::mutable_create_am_stmt() { ::pg_query::CreateAmStmt* _msg = _internal_mutable_create_am_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.create_am_stmt) return _msg; } // .pg_query.CreatePublicationStmt create_publication_stmt = 162 [json_name = "CreatePublicationStmt"]; inline bool Node::_internal_has_create_publication_stmt() const { return node_case() == kCreatePublicationStmt; } inline bool Node::has_create_publication_stmt() const { return _internal_has_create_publication_stmt(); } inline void Node::set_has_create_publication_stmt() { _impl_._oneof_case_[0] = kCreatePublicationStmt; } inline void Node::clear_create_publication_stmt() { if (_internal_has_create_publication_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_create_publication_stmt()) { clear_has_node(); ::pg_query::CreatePublicationStmt* temp = _impl_.node_.create_publication_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_create_publication_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.create_publication_stmt) return _internal_create_publication_stmt(); } inline ::pg_query::CreatePublicationStmt* Node::unsafe_arena_release_create_publication_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_publication_stmt) if (_internal_has_create_publication_stmt()) { clear_has_node(); ::pg_query::CreatePublicationStmt* temp = _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* create_publication_stmt) { clear_node(); if (create_publication_stmt) { set_has_create_publication_stmt(); _impl_.node_.create_publication_stmt_ = create_publication_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_publication_stmt) } inline ::pg_query::CreatePublicationStmt* Node::_internal_mutable_create_publication_stmt() { if (!_internal_has_create_publication_stmt()) { clear_node(); set_has_create_publication_stmt(); _impl_.node_.create_publication_stmt_ = CreateMaybeMessage< ::pg_query::CreatePublicationStmt >(GetArenaForAllocation()); } return _impl_.node_.create_publication_stmt_; } inline ::pg_query::CreatePublicationStmt* Node::mutable_create_publication_stmt() { ::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 = 163 [json_name = "AlterPublicationStmt"]; inline bool Node::_internal_has_alter_publication_stmt() const { return node_case() == kAlterPublicationStmt; } inline bool Node::has_alter_publication_stmt() const { return _internal_has_alter_publication_stmt(); } inline void Node::set_has_alter_publication_stmt() { _impl_._oneof_case_[0] = kAlterPublicationStmt; } inline void Node::clear_alter_publication_stmt() { if (_internal_has_alter_publication_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_publication_stmt()) { clear_has_node(); ::pg_query::AlterPublicationStmt* temp = _impl_.node_.alter_publication_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_publication_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_publication_stmt) return _internal_alter_publication_stmt(); } inline ::pg_query::AlterPublicationStmt* Node::unsafe_arena_release_alter_publication_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_publication_stmt) if (_internal_has_alter_publication_stmt()) { clear_has_node(); ::pg_query::AlterPublicationStmt* temp = _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* alter_publication_stmt) { clear_node(); if (alter_publication_stmt) { set_has_alter_publication_stmt(); _impl_.node_.alter_publication_stmt_ = alter_publication_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_publication_stmt) } inline ::pg_query::AlterPublicationStmt* Node::_internal_mutable_alter_publication_stmt() { if (!_internal_has_alter_publication_stmt()) { clear_node(); set_has_alter_publication_stmt(); _impl_.node_.alter_publication_stmt_ = CreateMaybeMessage< ::pg_query::AlterPublicationStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_publication_stmt_; } inline ::pg_query::AlterPublicationStmt* Node::mutable_alter_publication_stmt() { ::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 = 164 [json_name = "CreateSubscriptionStmt"]; inline bool Node::_internal_has_create_subscription_stmt() const { return node_case() == kCreateSubscriptionStmt; } inline bool Node::has_create_subscription_stmt() const { return _internal_has_create_subscription_stmt(); } inline void Node::set_has_create_subscription_stmt() { _impl_._oneof_case_[0] = kCreateSubscriptionStmt; } inline void Node::clear_create_subscription_stmt() { if (_internal_has_create_subscription_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_create_subscription_stmt()) { clear_has_node(); ::pg_query::CreateSubscriptionStmt* temp = _impl_.node_.create_subscription_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_create_subscription_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.create_subscription_stmt) return _internal_create_subscription_stmt(); } inline ::pg_query::CreateSubscriptionStmt* Node::unsafe_arena_release_create_subscription_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_subscription_stmt) if (_internal_has_create_subscription_stmt()) { clear_has_node(); ::pg_query::CreateSubscriptionStmt* temp = _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* create_subscription_stmt) { clear_node(); if (create_subscription_stmt) { set_has_create_subscription_stmt(); _impl_.node_.create_subscription_stmt_ = create_subscription_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_subscription_stmt) } inline ::pg_query::CreateSubscriptionStmt* Node::_internal_mutable_create_subscription_stmt() { if (!_internal_has_create_subscription_stmt()) { clear_node(); set_has_create_subscription_stmt(); _impl_.node_.create_subscription_stmt_ = CreateMaybeMessage< ::pg_query::CreateSubscriptionStmt >(GetArenaForAllocation()); } return _impl_.node_.create_subscription_stmt_; } inline ::pg_query::CreateSubscriptionStmt* Node::mutable_create_subscription_stmt() { ::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 = 165 [json_name = "AlterSubscriptionStmt"]; inline bool Node::_internal_has_alter_subscription_stmt() const { return node_case() == kAlterSubscriptionStmt; } inline bool Node::has_alter_subscription_stmt() const { return _internal_has_alter_subscription_stmt(); } inline void Node::set_has_alter_subscription_stmt() { _impl_._oneof_case_[0] = kAlterSubscriptionStmt; } inline void Node::clear_alter_subscription_stmt() { if (_internal_has_alter_subscription_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_subscription_stmt()) { clear_has_node(); ::pg_query::AlterSubscriptionStmt* temp = _impl_.node_.alter_subscription_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_subscription_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_subscription_stmt) return _internal_alter_subscription_stmt(); } inline ::pg_query::AlterSubscriptionStmt* Node::unsafe_arena_release_alter_subscription_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_subscription_stmt) if (_internal_has_alter_subscription_stmt()) { clear_has_node(); ::pg_query::AlterSubscriptionStmt* temp = _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* alter_subscription_stmt) { clear_node(); if (alter_subscription_stmt) { set_has_alter_subscription_stmt(); _impl_.node_.alter_subscription_stmt_ = alter_subscription_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_subscription_stmt) } inline ::pg_query::AlterSubscriptionStmt* Node::_internal_mutable_alter_subscription_stmt() { if (!_internal_has_alter_subscription_stmt()) { clear_node(); set_has_alter_subscription_stmt(); _impl_.node_.alter_subscription_stmt_ = CreateMaybeMessage< ::pg_query::AlterSubscriptionStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_subscription_stmt_; } inline ::pg_query::AlterSubscriptionStmt* Node::mutable_alter_subscription_stmt() { ::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 = 166 [json_name = "DropSubscriptionStmt"]; inline bool Node::_internal_has_drop_subscription_stmt() const { return node_case() == kDropSubscriptionStmt; } inline bool Node::has_drop_subscription_stmt() const { return _internal_has_drop_subscription_stmt(); } inline void Node::set_has_drop_subscription_stmt() { _impl_._oneof_case_[0] = kDropSubscriptionStmt; } inline void Node::clear_drop_subscription_stmt() { if (_internal_has_drop_subscription_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_drop_subscription_stmt()) { clear_has_node(); ::pg_query::DropSubscriptionStmt* temp = _impl_.node_.drop_subscription_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_drop_subscription_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.drop_subscription_stmt) return _internal_drop_subscription_stmt(); } inline ::pg_query::DropSubscriptionStmt* Node::unsafe_arena_release_drop_subscription_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.drop_subscription_stmt) if (_internal_has_drop_subscription_stmt()) { clear_has_node(); ::pg_query::DropSubscriptionStmt* temp = _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* drop_subscription_stmt) { clear_node(); if (drop_subscription_stmt) { set_has_drop_subscription_stmt(); _impl_.node_.drop_subscription_stmt_ = drop_subscription_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.drop_subscription_stmt) } inline ::pg_query::DropSubscriptionStmt* Node::_internal_mutable_drop_subscription_stmt() { if (!_internal_has_drop_subscription_stmt()) { clear_node(); set_has_drop_subscription_stmt(); _impl_.node_.drop_subscription_stmt_ = CreateMaybeMessage< ::pg_query::DropSubscriptionStmt >(GetArenaForAllocation()); } return _impl_.node_.drop_subscription_stmt_; } inline ::pg_query::DropSubscriptionStmt* Node::mutable_drop_subscription_stmt() { ::pg_query::DropSubscriptionStmt* _msg = _internal_mutable_drop_subscription_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.drop_subscription_stmt) return _msg; } // .pg_query.CreateStatsStmt create_stats_stmt = 167 [json_name = "CreateStatsStmt"]; inline bool Node::_internal_has_create_stats_stmt() const { return node_case() == kCreateStatsStmt; } inline bool Node::has_create_stats_stmt() const { return _internal_has_create_stats_stmt(); } inline void Node::set_has_create_stats_stmt() { _impl_._oneof_case_[0] = kCreateStatsStmt; } inline void Node::clear_create_stats_stmt() { if (_internal_has_create_stats_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_create_stats_stmt()) { clear_has_node(); ::pg_query::CreateStatsStmt* temp = _impl_.node_.create_stats_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_create_stats_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.create_stats_stmt) return _internal_create_stats_stmt(); } inline ::pg_query::CreateStatsStmt* Node::unsafe_arena_release_create_stats_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_stats_stmt) if (_internal_has_create_stats_stmt()) { clear_has_node(); ::pg_query::CreateStatsStmt* temp = _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* create_stats_stmt) { clear_node(); if (create_stats_stmt) { set_has_create_stats_stmt(); _impl_.node_.create_stats_stmt_ = create_stats_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_stats_stmt) } inline ::pg_query::CreateStatsStmt* Node::_internal_mutable_create_stats_stmt() { if (!_internal_has_create_stats_stmt()) { clear_node(); set_has_create_stats_stmt(); _impl_.node_.create_stats_stmt_ = CreateMaybeMessage< ::pg_query::CreateStatsStmt >(GetArenaForAllocation()); } return _impl_.node_.create_stats_stmt_; } inline ::pg_query::CreateStatsStmt* Node::mutable_create_stats_stmt() { ::pg_query::CreateStatsStmt* _msg = _internal_mutable_create_stats_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.create_stats_stmt) return _msg; } // .pg_query.AlterCollationStmt alter_collation_stmt = 168 [json_name = "AlterCollationStmt"]; inline bool Node::_internal_has_alter_collation_stmt() const { return node_case() == kAlterCollationStmt; } inline bool Node::has_alter_collation_stmt() const { return _internal_has_alter_collation_stmt(); } inline void Node::set_has_alter_collation_stmt() { _impl_._oneof_case_[0] = kAlterCollationStmt; } inline void Node::clear_alter_collation_stmt() { if (_internal_has_alter_collation_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_collation_stmt()) { clear_has_node(); ::pg_query::AlterCollationStmt* temp = _impl_.node_.alter_collation_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_collation_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_collation_stmt) return _internal_alter_collation_stmt(); } inline ::pg_query::AlterCollationStmt* Node::unsafe_arena_release_alter_collation_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_collation_stmt) if (_internal_has_alter_collation_stmt()) { clear_has_node(); ::pg_query::AlterCollationStmt* temp = _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* alter_collation_stmt) { clear_node(); if (alter_collation_stmt) { set_has_alter_collation_stmt(); _impl_.node_.alter_collation_stmt_ = alter_collation_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_collation_stmt) } inline ::pg_query::AlterCollationStmt* Node::_internal_mutable_alter_collation_stmt() { if (!_internal_has_alter_collation_stmt()) { clear_node(); set_has_alter_collation_stmt(); _impl_.node_.alter_collation_stmt_ = CreateMaybeMessage< ::pg_query::AlterCollationStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_collation_stmt_; } inline ::pg_query::AlterCollationStmt* Node::mutable_alter_collation_stmt() { ::pg_query::AlterCollationStmt* _msg = _internal_mutable_alter_collation_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_collation_stmt) return _msg; } // .pg_query.CallStmt call_stmt = 169 [json_name = "CallStmt"]; inline bool Node::_internal_has_call_stmt() const { return node_case() == kCallStmt; } inline bool Node::has_call_stmt() const { return _internal_has_call_stmt(); } inline void Node::set_has_call_stmt() { _impl_._oneof_case_[0] = kCallStmt; } inline void Node::clear_call_stmt() { if (_internal_has_call_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_call_stmt()) { clear_has_node(); ::pg_query::CallStmt* temp = _impl_.node_.call_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.call_stmt_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::CallStmt& Node::_internal_call_stmt() const { return _internal_has_call_stmt() ? *_impl_.node_.call_stmt_ : reinterpret_cast< ::pg_query::CallStmt&>(::pg_query::_CallStmt_default_instance_); } inline const ::pg_query::CallStmt& Node::call_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Node.call_stmt) return _internal_call_stmt(); } inline ::pg_query::CallStmt* Node::unsafe_arena_release_call_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.call_stmt) if (_internal_has_call_stmt()) { clear_has_node(); ::pg_query::CallStmt* temp = _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* call_stmt) { clear_node(); if (call_stmt) { set_has_call_stmt(); _impl_.node_.call_stmt_ = call_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.call_stmt) } inline ::pg_query::CallStmt* Node::_internal_mutable_call_stmt() { if (!_internal_has_call_stmt()) { clear_node(); set_has_call_stmt(); _impl_.node_.call_stmt_ = CreateMaybeMessage< ::pg_query::CallStmt >(GetArenaForAllocation()); } return _impl_.node_.call_stmt_; } inline ::pg_query::CallStmt* Node::mutable_call_stmt() { ::pg_query::CallStmt* _msg = _internal_mutable_call_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.call_stmt) return _msg; } // .pg_query.AlterStatsStmt alter_stats_stmt = 170 [json_name = "AlterStatsStmt"]; inline bool Node::_internal_has_alter_stats_stmt() const { return node_case() == kAlterStatsStmt; } inline bool Node::has_alter_stats_stmt() const { return _internal_has_alter_stats_stmt(); } inline void Node::set_has_alter_stats_stmt() { _impl_._oneof_case_[0] = kAlterStatsStmt; } inline void Node::clear_alter_stats_stmt() { if (_internal_has_alter_stats_stmt()) { if (GetArenaForAllocation() == 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 (_internal_has_alter_stats_stmt()) { clear_has_node(); ::pg_query::AlterStatsStmt* temp = _impl_.node_.alter_stats_stmt_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_alter_stats_stmt() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.alter_stats_stmt) return _internal_alter_stats_stmt(); } inline ::pg_query::AlterStatsStmt* Node::unsafe_arena_release_alter_stats_stmt() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.alter_stats_stmt) if (_internal_has_alter_stats_stmt()) { clear_has_node(); ::pg_query::AlterStatsStmt* temp = _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* alter_stats_stmt) { clear_node(); if (alter_stats_stmt) { set_has_alter_stats_stmt(); _impl_.node_.alter_stats_stmt_ = alter_stats_stmt; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.alter_stats_stmt) } inline ::pg_query::AlterStatsStmt* Node::_internal_mutable_alter_stats_stmt() { if (!_internal_has_alter_stats_stmt()) { clear_node(); set_has_alter_stats_stmt(); _impl_.node_.alter_stats_stmt_ = CreateMaybeMessage< ::pg_query::AlterStatsStmt >(GetArenaForAllocation()); } return _impl_.node_.alter_stats_stmt_; } inline ::pg_query::AlterStatsStmt* Node::mutable_alter_stats_stmt() { ::pg_query::AlterStatsStmt* _msg = _internal_mutable_alter_stats_stmt(); // @@protoc_insertion_point(field_mutable:pg_query.Node.alter_stats_stmt) return _msg; } // .pg_query.A_Expr a_expr = 171 [json_name = "A_Expr"]; inline bool Node::_internal_has_a_expr() const { return node_case() == kAExpr; } inline bool Node::has_a_expr() const { return _internal_has_a_expr(); } inline void Node::set_has_a_expr() { _impl_._oneof_case_[0] = kAExpr; } inline void Node::clear_a_expr() { if (_internal_has_a_expr()) { if (GetArenaForAllocation() == 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 (_internal_has_a_expr()) { clear_has_node(); ::pg_query::A_Expr* temp = _impl_.node_.a_expr_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_a_expr() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.a_expr) return _internal_a_expr(); } inline ::pg_query::A_Expr* Node::unsafe_arena_release_a_expr() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.a_expr) if (_internal_has_a_expr()) { clear_has_node(); ::pg_query::A_Expr* temp = _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* a_expr) { clear_node(); if (a_expr) { set_has_a_expr(); _impl_.node_.a_expr_ = a_expr; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.a_expr) } inline ::pg_query::A_Expr* Node::_internal_mutable_a_expr() { if (!_internal_has_a_expr()) { clear_node(); set_has_a_expr(); _impl_.node_.a_expr_ = CreateMaybeMessage< ::pg_query::A_Expr >(GetArenaForAllocation()); } return _impl_.node_.a_expr_; } inline ::pg_query::A_Expr* Node::mutable_a_expr() { ::pg_query::A_Expr* _msg = _internal_mutable_a_expr(); // @@protoc_insertion_point(field_mutable:pg_query.Node.a_expr) return _msg; } // .pg_query.ColumnRef column_ref = 172 [json_name = "ColumnRef"]; inline bool Node::_internal_has_column_ref() const { return node_case() == kColumnRef; } inline bool Node::has_column_ref() const { return _internal_has_column_ref(); } inline void Node::set_has_column_ref() { _impl_._oneof_case_[0] = kColumnRef; } inline void Node::clear_column_ref() { if (_internal_has_column_ref()) { if (GetArenaForAllocation() == 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 (_internal_has_column_ref()) { clear_has_node(); ::pg_query::ColumnRef* temp = _impl_.node_.column_ref_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.column_ref_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::ColumnRef& Node::_internal_column_ref() const { return _internal_has_column_ref() ? *_impl_.node_.column_ref_ : reinterpret_cast< ::pg_query::ColumnRef&>(::pg_query::_ColumnRef_default_instance_); } inline const ::pg_query::ColumnRef& Node::column_ref() const { // @@protoc_insertion_point(field_get:pg_query.Node.column_ref) return _internal_column_ref(); } inline ::pg_query::ColumnRef* Node::unsafe_arena_release_column_ref() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.column_ref) if (_internal_has_column_ref()) { clear_has_node(); ::pg_query::ColumnRef* temp = _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* column_ref) { clear_node(); if (column_ref) { set_has_column_ref(); _impl_.node_.column_ref_ = column_ref; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.column_ref) } inline ::pg_query::ColumnRef* Node::_internal_mutable_column_ref() { if (!_internal_has_column_ref()) { clear_node(); set_has_column_ref(); _impl_.node_.column_ref_ = CreateMaybeMessage< ::pg_query::ColumnRef >(GetArenaForAllocation()); } return _impl_.node_.column_ref_; } inline ::pg_query::ColumnRef* Node::mutable_column_ref() { ::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 = 173 [json_name = "ParamRef"]; inline bool Node::_internal_has_param_ref() const { return node_case() == kParamRef; } inline bool Node::has_param_ref() const { return _internal_has_param_ref(); } inline void Node::set_has_param_ref() { _impl_._oneof_case_[0] = kParamRef; } inline void Node::clear_param_ref() { if (_internal_has_param_ref()) { if (GetArenaForAllocation() == 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 (_internal_has_param_ref()) { clear_has_node(); ::pg_query::ParamRef* temp = _impl_.node_.param_ref_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.param_ref_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::ParamRef& Node::_internal_param_ref() const { return _internal_has_param_ref() ? *_impl_.node_.param_ref_ : reinterpret_cast< ::pg_query::ParamRef&>(::pg_query::_ParamRef_default_instance_); } inline const ::pg_query::ParamRef& Node::param_ref() const { // @@protoc_insertion_point(field_get:pg_query.Node.param_ref) return _internal_param_ref(); } inline ::pg_query::ParamRef* Node::unsafe_arena_release_param_ref() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.param_ref) if (_internal_has_param_ref()) { clear_has_node(); ::pg_query::ParamRef* temp = _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* param_ref) { clear_node(); if (param_ref) { set_has_param_ref(); _impl_.node_.param_ref_ = param_ref; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.param_ref) } inline ::pg_query::ParamRef* Node::_internal_mutable_param_ref() { if (!_internal_has_param_ref()) { clear_node(); set_has_param_ref(); _impl_.node_.param_ref_ = CreateMaybeMessage< ::pg_query::ParamRef >(GetArenaForAllocation()); } return _impl_.node_.param_ref_; } inline ::pg_query::ParamRef* Node::mutable_param_ref() { ::pg_query::ParamRef* _msg = _internal_mutable_param_ref(); // @@protoc_insertion_point(field_mutable:pg_query.Node.param_ref) return _msg; } // .pg_query.FuncCall func_call = 174 [json_name = "FuncCall"]; inline bool Node::_internal_has_func_call() const { return node_case() == kFuncCall; } inline bool Node::has_func_call() const { return _internal_has_func_call(); } inline void Node::set_has_func_call() { _impl_._oneof_case_[0] = kFuncCall; } inline void Node::clear_func_call() { if (_internal_has_func_call()) { if (GetArenaForAllocation() == 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 (_internal_has_func_call()) { clear_has_node(); ::pg_query::FuncCall* temp = _impl_.node_.func_call_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.func_call_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::FuncCall& Node::_internal_func_call() const { return _internal_has_func_call() ? *_impl_.node_.func_call_ : reinterpret_cast< ::pg_query::FuncCall&>(::pg_query::_FuncCall_default_instance_); } inline const ::pg_query::FuncCall& Node::func_call() const { // @@protoc_insertion_point(field_get:pg_query.Node.func_call) return _internal_func_call(); } inline ::pg_query::FuncCall* Node::unsafe_arena_release_func_call() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.func_call) if (_internal_has_func_call()) { clear_has_node(); ::pg_query::FuncCall* temp = _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* func_call) { clear_node(); if (func_call) { set_has_func_call(); _impl_.node_.func_call_ = func_call; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.func_call) } inline ::pg_query::FuncCall* Node::_internal_mutable_func_call() { if (!_internal_has_func_call()) { clear_node(); set_has_func_call(); _impl_.node_.func_call_ = CreateMaybeMessage< ::pg_query::FuncCall >(GetArenaForAllocation()); } return _impl_.node_.func_call_; } inline ::pg_query::FuncCall* Node::mutable_func_call() { ::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 = 175 [json_name = "A_Star"]; inline bool Node::_internal_has_a_star() const { return node_case() == kAStar; } inline bool Node::has_a_star() const { return _internal_has_a_star(); } inline void Node::set_has_a_star() { _impl_._oneof_case_[0] = kAStar; } inline void Node::clear_a_star() { if (_internal_has_a_star()) { if (GetArenaForAllocation() == 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 (_internal_has_a_star()) { clear_has_node(); ::pg_query::A_Star* temp = _impl_.node_.a_star_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_a_star() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.a_star) return _internal_a_star(); } inline ::pg_query::A_Star* Node::unsafe_arena_release_a_star() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.a_star) if (_internal_has_a_star()) { clear_has_node(); ::pg_query::A_Star* temp = _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* a_star) { clear_node(); if (a_star) { set_has_a_star(); _impl_.node_.a_star_ = a_star; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.a_star) } inline ::pg_query::A_Star* Node::_internal_mutable_a_star() { if (!_internal_has_a_star()) { clear_node(); set_has_a_star(); _impl_.node_.a_star_ = CreateMaybeMessage< ::pg_query::A_Star >(GetArenaForAllocation()); } return _impl_.node_.a_star_; } inline ::pg_query::A_Star* Node::mutable_a_star() { ::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 = 176 [json_name = "A_Indices"]; inline bool Node::_internal_has_a_indices() const { return node_case() == kAIndices; } inline bool Node::has_a_indices() const { return _internal_has_a_indices(); } inline void Node::set_has_a_indices() { _impl_._oneof_case_[0] = kAIndices; } inline void Node::clear_a_indices() { if (_internal_has_a_indices()) { if (GetArenaForAllocation() == 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 (_internal_has_a_indices()) { clear_has_node(); ::pg_query::A_Indices* temp = _impl_.node_.a_indices_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_a_indices() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.a_indices) return _internal_a_indices(); } inline ::pg_query::A_Indices* Node::unsafe_arena_release_a_indices() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.a_indices) if (_internal_has_a_indices()) { clear_has_node(); ::pg_query::A_Indices* temp = _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* a_indices) { clear_node(); if (a_indices) { set_has_a_indices(); _impl_.node_.a_indices_ = a_indices; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.a_indices) } inline ::pg_query::A_Indices* Node::_internal_mutable_a_indices() { if (!_internal_has_a_indices()) { clear_node(); set_has_a_indices(); _impl_.node_.a_indices_ = CreateMaybeMessage< ::pg_query::A_Indices >(GetArenaForAllocation()); } return _impl_.node_.a_indices_; } inline ::pg_query::A_Indices* Node::mutable_a_indices() { ::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 = 177 [json_name = "A_Indirection"]; inline bool Node::_internal_has_a_indirection() const { return node_case() == kAIndirection; } inline bool Node::has_a_indirection() const { return _internal_has_a_indirection(); } inline void Node::set_has_a_indirection() { _impl_._oneof_case_[0] = kAIndirection; } inline void Node::clear_a_indirection() { if (_internal_has_a_indirection()) { if (GetArenaForAllocation() == 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 (_internal_has_a_indirection()) { clear_has_node(); ::pg_query::A_Indirection* temp = _impl_.node_.a_indirection_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_a_indirection() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.a_indirection) return _internal_a_indirection(); } inline ::pg_query::A_Indirection* Node::unsafe_arena_release_a_indirection() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.a_indirection) if (_internal_has_a_indirection()) { clear_has_node(); ::pg_query::A_Indirection* temp = _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* a_indirection) { clear_node(); if (a_indirection) { set_has_a_indirection(); _impl_.node_.a_indirection_ = a_indirection; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.a_indirection) } inline ::pg_query::A_Indirection* Node::_internal_mutable_a_indirection() { if (!_internal_has_a_indirection()) { clear_node(); set_has_a_indirection(); _impl_.node_.a_indirection_ = CreateMaybeMessage< ::pg_query::A_Indirection >(GetArenaForAllocation()); } return _impl_.node_.a_indirection_; } inline ::pg_query::A_Indirection* Node::mutable_a_indirection() { ::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 = 178 [json_name = "A_ArrayExpr"]; inline bool Node::_internal_has_a_array_expr() const { return node_case() == kAArrayExpr; } inline bool Node::has_a_array_expr() const { return _internal_has_a_array_expr(); } inline void Node::set_has_a_array_expr() { _impl_._oneof_case_[0] = kAArrayExpr; } inline void Node::clear_a_array_expr() { if (_internal_has_a_array_expr()) { if (GetArenaForAllocation() == 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 (_internal_has_a_array_expr()) { clear_has_node(); ::pg_query::A_ArrayExpr* temp = _impl_.node_.a_array_expr_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_a_array_expr() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.a_array_expr) return _internal_a_array_expr(); } inline ::pg_query::A_ArrayExpr* Node::unsafe_arena_release_a_array_expr() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.a_array_expr) if (_internal_has_a_array_expr()) { clear_has_node(); ::pg_query::A_ArrayExpr* temp = _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* a_array_expr) { clear_node(); if (a_array_expr) { set_has_a_array_expr(); _impl_.node_.a_array_expr_ = a_array_expr; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.a_array_expr) } inline ::pg_query::A_ArrayExpr* Node::_internal_mutable_a_array_expr() { if (!_internal_has_a_array_expr()) { clear_node(); set_has_a_array_expr(); _impl_.node_.a_array_expr_ = CreateMaybeMessage< ::pg_query::A_ArrayExpr >(GetArenaForAllocation()); } return _impl_.node_.a_array_expr_; } inline ::pg_query::A_ArrayExpr* Node::mutable_a_array_expr() { ::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 = 179 [json_name = "ResTarget"]; inline bool Node::_internal_has_res_target() const { return node_case() == kResTarget; } inline bool Node::has_res_target() const { return _internal_has_res_target(); } inline void Node::set_has_res_target() { _impl_._oneof_case_[0] = kResTarget; } inline void Node::clear_res_target() { if (_internal_has_res_target()) { if (GetArenaForAllocation() == 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 (_internal_has_res_target()) { clear_has_node(); ::pg_query::ResTarget* temp = _impl_.node_.res_target_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.res_target_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::ResTarget& Node::_internal_res_target() const { return _internal_has_res_target() ? *_impl_.node_.res_target_ : reinterpret_cast< ::pg_query::ResTarget&>(::pg_query::_ResTarget_default_instance_); } inline const ::pg_query::ResTarget& Node::res_target() const { // @@protoc_insertion_point(field_get:pg_query.Node.res_target) return _internal_res_target(); } inline ::pg_query::ResTarget* Node::unsafe_arena_release_res_target() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.res_target) if (_internal_has_res_target()) { clear_has_node(); ::pg_query::ResTarget* temp = _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* res_target) { clear_node(); if (res_target) { set_has_res_target(); _impl_.node_.res_target_ = res_target; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.res_target) } inline ::pg_query::ResTarget* Node::_internal_mutable_res_target() { if (!_internal_has_res_target()) { clear_node(); set_has_res_target(); _impl_.node_.res_target_ = CreateMaybeMessage< ::pg_query::ResTarget >(GetArenaForAllocation()); } return _impl_.node_.res_target_; } inline ::pg_query::ResTarget* Node::mutable_res_target() { ::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 = 180 [json_name = "MultiAssignRef"]; inline bool Node::_internal_has_multi_assign_ref() const { return node_case() == kMultiAssignRef; } inline bool Node::has_multi_assign_ref() const { return _internal_has_multi_assign_ref(); } inline void Node::set_has_multi_assign_ref() { _impl_._oneof_case_[0] = kMultiAssignRef; } inline void Node::clear_multi_assign_ref() { if (_internal_has_multi_assign_ref()) { if (GetArenaForAllocation() == 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 (_internal_has_multi_assign_ref()) { clear_has_node(); ::pg_query::MultiAssignRef* temp = _impl_.node_.multi_assign_ref_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_multi_assign_ref() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.multi_assign_ref) return _internal_multi_assign_ref(); } inline ::pg_query::MultiAssignRef* Node::unsafe_arena_release_multi_assign_ref() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.multi_assign_ref) if (_internal_has_multi_assign_ref()) { clear_has_node(); ::pg_query::MultiAssignRef* temp = _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* multi_assign_ref) { clear_node(); if (multi_assign_ref) { set_has_multi_assign_ref(); _impl_.node_.multi_assign_ref_ = multi_assign_ref; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.multi_assign_ref) } inline ::pg_query::MultiAssignRef* Node::_internal_mutable_multi_assign_ref() { if (!_internal_has_multi_assign_ref()) { clear_node(); set_has_multi_assign_ref(); _impl_.node_.multi_assign_ref_ = CreateMaybeMessage< ::pg_query::MultiAssignRef >(GetArenaForAllocation()); } return _impl_.node_.multi_assign_ref_; } inline ::pg_query::MultiAssignRef* Node::mutable_multi_assign_ref() { ::pg_query::MultiAssignRef* _msg = _internal_mutable_multi_assign_ref(); // @@protoc_insertion_point(field_mutable:pg_query.Node.multi_assign_ref) return _msg; } // .pg_query.TypeCast type_cast = 181 [json_name = "TypeCast"]; inline bool Node::_internal_has_type_cast() const { return node_case() == kTypeCast; } inline bool Node::has_type_cast() const { return _internal_has_type_cast(); } inline void Node::set_has_type_cast() { _impl_._oneof_case_[0] = kTypeCast; } inline void Node::clear_type_cast() { if (_internal_has_type_cast()) { if (GetArenaForAllocation() == 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 (_internal_has_type_cast()) { clear_has_node(); ::pg_query::TypeCast* temp = _impl_.node_.type_cast_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.type_cast_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::TypeCast& Node::_internal_type_cast() const { return _internal_has_type_cast() ? *_impl_.node_.type_cast_ : reinterpret_cast< ::pg_query::TypeCast&>(::pg_query::_TypeCast_default_instance_); } inline const ::pg_query::TypeCast& Node::type_cast() const { // @@protoc_insertion_point(field_get:pg_query.Node.type_cast) return _internal_type_cast(); } inline ::pg_query::TypeCast* Node::unsafe_arena_release_type_cast() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.type_cast) if (_internal_has_type_cast()) { clear_has_node(); ::pg_query::TypeCast* temp = _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* type_cast) { clear_node(); if (type_cast) { set_has_type_cast(); _impl_.node_.type_cast_ = type_cast; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.type_cast) } inline ::pg_query::TypeCast* Node::_internal_mutable_type_cast() { if (!_internal_has_type_cast()) { clear_node(); set_has_type_cast(); _impl_.node_.type_cast_ = CreateMaybeMessage< ::pg_query::TypeCast >(GetArenaForAllocation()); } return _impl_.node_.type_cast_; } inline ::pg_query::TypeCast* Node::mutable_type_cast() { ::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 = 182 [json_name = "CollateClause"]; inline bool Node::_internal_has_collate_clause() const { return node_case() == kCollateClause; } inline bool Node::has_collate_clause() const { return _internal_has_collate_clause(); } inline void Node::set_has_collate_clause() { _impl_._oneof_case_[0] = kCollateClause; } inline void Node::clear_collate_clause() { if (_internal_has_collate_clause()) { if (GetArenaForAllocation() == 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 (_internal_has_collate_clause()) { clear_has_node(); ::pg_query::CollateClause* temp = _impl_.node_.collate_clause_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.collate_clause_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::CollateClause& Node::_internal_collate_clause() const { return _internal_has_collate_clause() ? *_impl_.node_.collate_clause_ : reinterpret_cast< ::pg_query::CollateClause&>(::pg_query::_CollateClause_default_instance_); } inline const ::pg_query::CollateClause& Node::collate_clause() const { // @@protoc_insertion_point(field_get:pg_query.Node.collate_clause) return _internal_collate_clause(); } inline ::pg_query::CollateClause* Node::unsafe_arena_release_collate_clause() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.collate_clause) if (_internal_has_collate_clause()) { clear_has_node(); ::pg_query::CollateClause* temp = _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* collate_clause) { clear_node(); if (collate_clause) { set_has_collate_clause(); _impl_.node_.collate_clause_ = collate_clause; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.collate_clause) } inline ::pg_query::CollateClause* Node::_internal_mutable_collate_clause() { if (!_internal_has_collate_clause()) { clear_node(); set_has_collate_clause(); _impl_.node_.collate_clause_ = CreateMaybeMessage< ::pg_query::CollateClause >(GetArenaForAllocation()); } return _impl_.node_.collate_clause_; } inline ::pg_query::CollateClause* Node::mutable_collate_clause() { ::pg_query::CollateClause* _msg = _internal_mutable_collate_clause(); // @@protoc_insertion_point(field_mutable:pg_query.Node.collate_clause) return _msg; } // .pg_query.SortBy sort_by = 183 [json_name = "SortBy"]; inline bool Node::_internal_has_sort_by() const { return node_case() == kSortBy; } inline bool Node::has_sort_by() const { return _internal_has_sort_by(); } inline void Node::set_has_sort_by() { _impl_._oneof_case_[0] = kSortBy; } inline void Node::clear_sort_by() { if (_internal_has_sort_by()) { if (GetArenaForAllocation() == 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 (_internal_has_sort_by()) { clear_has_node(); ::pg_query::SortBy* temp = _impl_.node_.sort_by_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.sort_by_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::SortBy& Node::_internal_sort_by() const { return _internal_has_sort_by() ? *_impl_.node_.sort_by_ : reinterpret_cast< ::pg_query::SortBy&>(::pg_query::_SortBy_default_instance_); } inline const ::pg_query::SortBy& Node::sort_by() const { // @@protoc_insertion_point(field_get:pg_query.Node.sort_by) return _internal_sort_by(); } inline ::pg_query::SortBy* Node::unsafe_arena_release_sort_by() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.sort_by) if (_internal_has_sort_by()) { clear_has_node(); ::pg_query::SortBy* temp = _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* sort_by) { clear_node(); if (sort_by) { set_has_sort_by(); _impl_.node_.sort_by_ = sort_by; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.sort_by) } inline ::pg_query::SortBy* Node::_internal_mutable_sort_by() { if (!_internal_has_sort_by()) { clear_node(); set_has_sort_by(); _impl_.node_.sort_by_ = CreateMaybeMessage< ::pg_query::SortBy >(GetArenaForAllocation()); } return _impl_.node_.sort_by_; } inline ::pg_query::SortBy* Node::mutable_sort_by() { ::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 = 184 [json_name = "WindowDef"]; inline bool Node::_internal_has_window_def() const { return node_case() == kWindowDef; } inline bool Node::has_window_def() const { return _internal_has_window_def(); } inline void Node::set_has_window_def() { _impl_._oneof_case_[0] = kWindowDef; } inline void Node::clear_window_def() { if (_internal_has_window_def()) { if (GetArenaForAllocation() == 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 (_internal_has_window_def()) { clear_has_node(); ::pg_query::WindowDef* temp = _impl_.node_.window_def_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.window_def_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::WindowDef& Node::_internal_window_def() const { return _internal_has_window_def() ? *_impl_.node_.window_def_ : reinterpret_cast< ::pg_query::WindowDef&>(::pg_query::_WindowDef_default_instance_); } inline const ::pg_query::WindowDef& Node::window_def() const { // @@protoc_insertion_point(field_get:pg_query.Node.window_def) return _internal_window_def(); } inline ::pg_query::WindowDef* Node::unsafe_arena_release_window_def() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.window_def) if (_internal_has_window_def()) { clear_has_node(); ::pg_query::WindowDef* temp = _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* window_def) { clear_node(); if (window_def) { set_has_window_def(); _impl_.node_.window_def_ = window_def; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.window_def) } inline ::pg_query::WindowDef* Node::_internal_mutable_window_def() { if (!_internal_has_window_def()) { clear_node(); set_has_window_def(); _impl_.node_.window_def_ = CreateMaybeMessage< ::pg_query::WindowDef >(GetArenaForAllocation()); } return _impl_.node_.window_def_; } inline ::pg_query::WindowDef* Node::mutable_window_def() { ::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 = 185 [json_name = "RangeSubselect"]; inline bool Node::_internal_has_range_subselect() const { return node_case() == kRangeSubselect; } inline bool Node::has_range_subselect() const { return _internal_has_range_subselect(); } inline void Node::set_has_range_subselect() { _impl_._oneof_case_[0] = kRangeSubselect; } inline void Node::clear_range_subselect() { if (_internal_has_range_subselect()) { if (GetArenaForAllocation() == 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 (_internal_has_range_subselect()) { clear_has_node(); ::pg_query::RangeSubselect* temp = _impl_.node_.range_subselect_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.range_subselect_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::RangeSubselect& Node::_internal_range_subselect() const { return _internal_has_range_subselect() ? *_impl_.node_.range_subselect_ : reinterpret_cast< ::pg_query::RangeSubselect&>(::pg_query::_RangeSubselect_default_instance_); } inline const ::pg_query::RangeSubselect& Node::range_subselect() const { // @@protoc_insertion_point(field_get:pg_query.Node.range_subselect) return _internal_range_subselect(); } inline ::pg_query::RangeSubselect* Node::unsafe_arena_release_range_subselect() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.range_subselect) if (_internal_has_range_subselect()) { clear_has_node(); ::pg_query::RangeSubselect* temp = _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* range_subselect) { clear_node(); if (range_subselect) { set_has_range_subselect(); _impl_.node_.range_subselect_ = range_subselect; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.range_subselect) } inline ::pg_query::RangeSubselect* Node::_internal_mutable_range_subselect() { if (!_internal_has_range_subselect()) { clear_node(); set_has_range_subselect(); _impl_.node_.range_subselect_ = CreateMaybeMessage< ::pg_query::RangeSubselect >(GetArenaForAllocation()); } return _impl_.node_.range_subselect_; } inline ::pg_query::RangeSubselect* Node::mutable_range_subselect() { ::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 = 186 [json_name = "RangeFunction"]; inline bool Node::_internal_has_range_function() const { return node_case() == kRangeFunction; } inline bool Node::has_range_function() const { return _internal_has_range_function(); } inline void Node::set_has_range_function() { _impl_._oneof_case_[0] = kRangeFunction; } inline void Node::clear_range_function() { if (_internal_has_range_function()) { if (GetArenaForAllocation() == 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 (_internal_has_range_function()) { clear_has_node(); ::pg_query::RangeFunction* temp = _impl_.node_.range_function_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.range_function_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::RangeFunction& Node::_internal_range_function() const { return _internal_has_range_function() ? *_impl_.node_.range_function_ : reinterpret_cast< ::pg_query::RangeFunction&>(::pg_query::_RangeFunction_default_instance_); } inline const ::pg_query::RangeFunction& Node::range_function() const { // @@protoc_insertion_point(field_get:pg_query.Node.range_function) return _internal_range_function(); } inline ::pg_query::RangeFunction* Node::unsafe_arena_release_range_function() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.range_function) if (_internal_has_range_function()) { clear_has_node(); ::pg_query::RangeFunction* temp = _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* range_function) { clear_node(); if (range_function) { set_has_range_function(); _impl_.node_.range_function_ = range_function; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.range_function) } inline ::pg_query::RangeFunction* Node::_internal_mutable_range_function() { if (!_internal_has_range_function()) { clear_node(); set_has_range_function(); _impl_.node_.range_function_ = CreateMaybeMessage< ::pg_query::RangeFunction >(GetArenaForAllocation()); } return _impl_.node_.range_function_; } inline ::pg_query::RangeFunction* Node::mutable_range_function() { ::pg_query::RangeFunction* _msg = _internal_mutable_range_function(); // @@protoc_insertion_point(field_mutable:pg_query.Node.range_function) return _msg; } // .pg_query.RangeTableSample range_table_sample = 187 [json_name = "RangeTableSample"]; inline bool Node::_internal_has_range_table_sample() const { return node_case() == kRangeTableSample; } inline bool Node::has_range_table_sample() const { return _internal_has_range_table_sample(); } inline void Node::set_has_range_table_sample() { _impl_._oneof_case_[0] = kRangeTableSample; } inline void Node::clear_range_table_sample() { if (_internal_has_range_table_sample()) { if (GetArenaForAllocation() == 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 (_internal_has_range_table_sample()) { clear_has_node(); ::pg_query::RangeTableSample* temp = _impl_.node_.range_table_sample_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_range_table_sample() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.range_table_sample) return _internal_range_table_sample(); } inline ::pg_query::RangeTableSample* Node::unsafe_arena_release_range_table_sample() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.range_table_sample) if (_internal_has_range_table_sample()) { clear_has_node(); ::pg_query::RangeTableSample* temp = _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* range_table_sample) { clear_node(); if (range_table_sample) { set_has_range_table_sample(); _impl_.node_.range_table_sample_ = range_table_sample; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.range_table_sample) } inline ::pg_query::RangeTableSample* Node::_internal_mutable_range_table_sample() { if (!_internal_has_range_table_sample()) { clear_node(); set_has_range_table_sample(); _impl_.node_.range_table_sample_ = CreateMaybeMessage< ::pg_query::RangeTableSample >(GetArenaForAllocation()); } return _impl_.node_.range_table_sample_; } inline ::pg_query::RangeTableSample* Node::mutable_range_table_sample() { ::pg_query::RangeTableSample* _msg = _internal_mutable_range_table_sample(); // @@protoc_insertion_point(field_mutable:pg_query.Node.range_table_sample) return _msg; } // .pg_query.RangeTableFunc range_table_func = 188 [json_name = "RangeTableFunc"]; inline bool Node::_internal_has_range_table_func() const { return node_case() == kRangeTableFunc; } inline bool Node::has_range_table_func() const { return _internal_has_range_table_func(); } inline void Node::set_has_range_table_func() { _impl_._oneof_case_[0] = kRangeTableFunc; } inline void Node::clear_range_table_func() { if (_internal_has_range_table_func()) { if (GetArenaForAllocation() == 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 (_internal_has_range_table_func()) { clear_has_node(); ::pg_query::RangeTableFunc* temp = _impl_.node_.range_table_func_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_range_table_func() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.range_table_func) return _internal_range_table_func(); } inline ::pg_query::RangeTableFunc* Node::unsafe_arena_release_range_table_func() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.range_table_func) if (_internal_has_range_table_func()) { clear_has_node(); ::pg_query::RangeTableFunc* temp = _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* range_table_func) { clear_node(); if (range_table_func) { set_has_range_table_func(); _impl_.node_.range_table_func_ = range_table_func; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.range_table_func) } inline ::pg_query::RangeTableFunc* Node::_internal_mutable_range_table_func() { if (!_internal_has_range_table_func()) { clear_node(); set_has_range_table_func(); _impl_.node_.range_table_func_ = CreateMaybeMessage< ::pg_query::RangeTableFunc >(GetArenaForAllocation()); } return _impl_.node_.range_table_func_; } inline ::pg_query::RangeTableFunc* Node::mutable_range_table_func() { ::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 = 189 [json_name = "RangeTableFuncCol"]; inline bool Node::_internal_has_range_table_func_col() const { return node_case() == kRangeTableFuncCol; } inline bool Node::has_range_table_func_col() const { return _internal_has_range_table_func_col(); } inline void Node::set_has_range_table_func_col() { _impl_._oneof_case_[0] = kRangeTableFuncCol; } inline void Node::clear_range_table_func_col() { if (_internal_has_range_table_func_col()) { if (GetArenaForAllocation() == 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 (_internal_has_range_table_func_col()) { clear_has_node(); ::pg_query::RangeTableFuncCol* temp = _impl_.node_.range_table_func_col_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_range_table_func_col() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.range_table_func_col) return _internal_range_table_func_col(); } inline ::pg_query::RangeTableFuncCol* Node::unsafe_arena_release_range_table_func_col() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.range_table_func_col) if (_internal_has_range_table_func_col()) { clear_has_node(); ::pg_query::RangeTableFuncCol* temp = _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* range_table_func_col) { clear_node(); if (range_table_func_col) { set_has_range_table_func_col(); _impl_.node_.range_table_func_col_ = range_table_func_col; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.range_table_func_col) } inline ::pg_query::RangeTableFuncCol* Node::_internal_mutable_range_table_func_col() { if (!_internal_has_range_table_func_col()) { clear_node(); set_has_range_table_func_col(); _impl_.node_.range_table_func_col_ = CreateMaybeMessage< ::pg_query::RangeTableFuncCol >(GetArenaForAllocation()); } return _impl_.node_.range_table_func_col_; } inline ::pg_query::RangeTableFuncCol* Node::mutable_range_table_func_col() { ::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.TypeName type_name = 190 [json_name = "TypeName"]; inline bool Node::_internal_has_type_name() const { return node_case() == kTypeName; } inline bool Node::has_type_name() const { return _internal_has_type_name(); } inline void Node::set_has_type_name() { _impl_._oneof_case_[0] = kTypeName; } inline void Node::clear_type_name() { if (_internal_has_type_name()) { if (GetArenaForAllocation() == 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 (_internal_has_type_name()) { clear_has_node(); ::pg_query::TypeName* temp = _impl_.node_.type_name_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.type_name_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::TypeName& Node::_internal_type_name() const { return _internal_has_type_name() ? *_impl_.node_.type_name_ : reinterpret_cast< ::pg_query::TypeName&>(::pg_query::_TypeName_default_instance_); } inline const ::pg_query::TypeName& Node::type_name() const { // @@protoc_insertion_point(field_get:pg_query.Node.type_name) return _internal_type_name(); } inline ::pg_query::TypeName* Node::unsafe_arena_release_type_name() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.type_name) if (_internal_has_type_name()) { clear_has_node(); ::pg_query::TypeName* temp = _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* type_name) { clear_node(); if (type_name) { set_has_type_name(); _impl_.node_.type_name_ = type_name; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.type_name) } inline ::pg_query::TypeName* Node::_internal_mutable_type_name() { if (!_internal_has_type_name()) { clear_node(); set_has_type_name(); _impl_.node_.type_name_ = CreateMaybeMessage< ::pg_query::TypeName >(GetArenaForAllocation()); } return _impl_.node_.type_name_; } inline ::pg_query::TypeName* Node::mutable_type_name() { ::pg_query::TypeName* _msg = _internal_mutable_type_name(); // @@protoc_insertion_point(field_mutable:pg_query.Node.type_name) return _msg; } // .pg_query.ColumnDef column_def = 191 [json_name = "ColumnDef"]; inline bool Node::_internal_has_column_def() const { return node_case() == kColumnDef; } inline bool Node::has_column_def() const { return _internal_has_column_def(); } inline void Node::set_has_column_def() { _impl_._oneof_case_[0] = kColumnDef; } inline void Node::clear_column_def() { if (_internal_has_column_def()) { if (GetArenaForAllocation() == 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 (_internal_has_column_def()) { clear_has_node(); ::pg_query::ColumnDef* temp = _impl_.node_.column_def_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.column_def_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::ColumnDef& Node::_internal_column_def() const { return _internal_has_column_def() ? *_impl_.node_.column_def_ : reinterpret_cast< ::pg_query::ColumnDef&>(::pg_query::_ColumnDef_default_instance_); } inline const ::pg_query::ColumnDef& Node::column_def() const { // @@protoc_insertion_point(field_get:pg_query.Node.column_def) return _internal_column_def(); } inline ::pg_query::ColumnDef* Node::unsafe_arena_release_column_def() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.column_def) if (_internal_has_column_def()) { clear_has_node(); ::pg_query::ColumnDef* temp = _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* column_def) { clear_node(); if (column_def) { set_has_column_def(); _impl_.node_.column_def_ = column_def; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.column_def) } inline ::pg_query::ColumnDef* Node::_internal_mutable_column_def() { if (!_internal_has_column_def()) { clear_node(); set_has_column_def(); _impl_.node_.column_def_ = CreateMaybeMessage< ::pg_query::ColumnDef >(GetArenaForAllocation()); } return _impl_.node_.column_def_; } inline ::pg_query::ColumnDef* Node::mutable_column_def() { ::pg_query::ColumnDef* _msg = _internal_mutable_column_def(); // @@protoc_insertion_point(field_mutable:pg_query.Node.column_def) return _msg; } // .pg_query.IndexElem index_elem = 192 [json_name = "IndexElem"]; inline bool Node::_internal_has_index_elem() const { return node_case() == kIndexElem; } inline bool Node::has_index_elem() const { return _internal_has_index_elem(); } inline void Node::set_has_index_elem() { _impl_._oneof_case_[0] = kIndexElem; } inline void Node::clear_index_elem() { if (_internal_has_index_elem()) { if (GetArenaForAllocation() == 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 (_internal_has_index_elem()) { clear_has_node(); ::pg_query::IndexElem* temp = _impl_.node_.index_elem_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.index_elem_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::IndexElem& Node::_internal_index_elem() const { return _internal_has_index_elem() ? *_impl_.node_.index_elem_ : reinterpret_cast< ::pg_query::IndexElem&>(::pg_query::_IndexElem_default_instance_); } inline const ::pg_query::IndexElem& Node::index_elem() const { // @@protoc_insertion_point(field_get:pg_query.Node.index_elem) return _internal_index_elem(); } inline ::pg_query::IndexElem* Node::unsafe_arena_release_index_elem() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.index_elem) if (_internal_has_index_elem()) { clear_has_node(); ::pg_query::IndexElem* temp = _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* index_elem) { clear_node(); if (index_elem) { set_has_index_elem(); _impl_.node_.index_elem_ = index_elem; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.index_elem) } inline ::pg_query::IndexElem* Node::_internal_mutable_index_elem() { if (!_internal_has_index_elem()) { clear_node(); set_has_index_elem(); _impl_.node_.index_elem_ = CreateMaybeMessage< ::pg_query::IndexElem >(GetArenaForAllocation()); } return _impl_.node_.index_elem_; } inline ::pg_query::IndexElem* Node::mutable_index_elem() { ::pg_query::IndexElem* _msg = _internal_mutable_index_elem(); // @@protoc_insertion_point(field_mutable:pg_query.Node.index_elem) return _msg; } // .pg_query.StatsElem stats_elem = 193 [json_name = "StatsElem"]; inline bool Node::_internal_has_stats_elem() const { return node_case() == kStatsElem; } inline bool Node::has_stats_elem() const { return _internal_has_stats_elem(); } inline void Node::set_has_stats_elem() { _impl_._oneof_case_[0] = kStatsElem; } inline void Node::clear_stats_elem() { if (_internal_has_stats_elem()) { if (GetArenaForAllocation() == 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 (_internal_has_stats_elem()) { clear_has_node(); ::pg_query::StatsElem* temp = _impl_.node_.stats_elem_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.stats_elem_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::StatsElem& Node::_internal_stats_elem() const { return _internal_has_stats_elem() ? *_impl_.node_.stats_elem_ : reinterpret_cast< ::pg_query::StatsElem&>(::pg_query::_StatsElem_default_instance_); } inline const ::pg_query::StatsElem& Node::stats_elem() const { // @@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 (_internal_has_stats_elem()) { clear_has_node(); ::pg_query::StatsElem* 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* stats_elem) { clear_node(); if (stats_elem) { set_has_stats_elem(); _impl_.node_.stats_elem_ = stats_elem; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.stats_elem) } inline ::pg_query::StatsElem* Node::_internal_mutable_stats_elem() { if (!_internal_has_stats_elem()) { clear_node(); set_has_stats_elem(); _impl_.node_.stats_elem_ = CreateMaybeMessage< ::pg_query::StatsElem >(GetArenaForAllocation()); } return _impl_.node_.stats_elem_; } inline ::pg_query::StatsElem* Node::mutable_stats_elem() { ::pg_query::StatsElem* _msg = _internal_mutable_stats_elem(); // @@protoc_insertion_point(field_mutable:pg_query.Node.stats_elem) return _msg; } // .pg_query.Constraint constraint = 194 [json_name = "Constraint"]; inline bool Node::_internal_has_constraint() const { return node_case() == kConstraint; } inline bool Node::has_constraint() const { return _internal_has_constraint(); } inline void Node::set_has_constraint() { _impl_._oneof_case_[0] = kConstraint; } inline void Node::clear_constraint() { if (_internal_has_constraint()) { if (GetArenaForAllocation() == 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 (_internal_has_constraint()) { clear_has_node(); ::pg_query::Constraint* temp = _impl_.node_.constraint_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.constraint_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::Constraint& Node::_internal_constraint() const { return _internal_has_constraint() ? *_impl_.node_.constraint_ : reinterpret_cast< ::pg_query::Constraint&>(::pg_query::_Constraint_default_instance_); } inline const ::pg_query::Constraint& Node::constraint() const { // @@protoc_insertion_point(field_get:pg_query.Node.constraint) return _internal_constraint(); } inline ::pg_query::Constraint* Node::unsafe_arena_release_constraint() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.constraint) if (_internal_has_constraint()) { clear_has_node(); ::pg_query::Constraint* temp = _impl_.node_.constraint_; _impl_.node_.constraint_ = nullptr; return temp; } else { return nullptr; } } inline void Node::unsafe_arena_set_allocated_constraint(::pg_query::Constraint* constraint) { clear_node(); if (constraint) { set_has_constraint(); _impl_.node_.constraint_ = constraint; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.constraint) } inline ::pg_query::Constraint* Node::_internal_mutable_constraint() { if (!_internal_has_constraint()) { clear_node(); set_has_constraint(); _impl_.node_.constraint_ = CreateMaybeMessage< ::pg_query::Constraint >(GetArenaForAllocation()); } return _impl_.node_.constraint_; } inline ::pg_query::Constraint* Node::mutable_constraint() { ::pg_query::Constraint* _msg = _internal_mutable_constraint(); // @@protoc_insertion_point(field_mutable:pg_query.Node.constraint) return _msg; } // .pg_query.DefElem def_elem = 195 [json_name = "DefElem"]; inline bool Node::_internal_has_def_elem() const { return node_case() == kDefElem; } inline bool Node::has_def_elem() const { return _internal_has_def_elem(); } inline void Node::set_has_def_elem() { _impl_._oneof_case_[0] = kDefElem; } inline void Node::clear_def_elem() { if (_internal_has_def_elem()) { if (GetArenaForAllocation() == 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 (_internal_has_def_elem()) { clear_has_node(); ::pg_query::DefElem* temp = _impl_.node_.def_elem_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.def_elem_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::DefElem& Node::_internal_def_elem() const { return _internal_has_def_elem() ? *_impl_.node_.def_elem_ : reinterpret_cast< ::pg_query::DefElem&>(::pg_query::_DefElem_default_instance_); } inline const ::pg_query::DefElem& Node::def_elem() const { // @@protoc_insertion_point(field_get:pg_query.Node.def_elem) return _internal_def_elem(); } inline ::pg_query::DefElem* Node::unsafe_arena_release_def_elem() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.def_elem) if (_internal_has_def_elem()) { clear_has_node(); ::pg_query::DefElem* temp = _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* def_elem) { clear_node(); if (def_elem) { set_has_def_elem(); _impl_.node_.def_elem_ = def_elem; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.def_elem) } inline ::pg_query::DefElem* Node::_internal_mutable_def_elem() { if (!_internal_has_def_elem()) { clear_node(); set_has_def_elem(); _impl_.node_.def_elem_ = CreateMaybeMessage< ::pg_query::DefElem >(GetArenaForAllocation()); } return _impl_.node_.def_elem_; } inline ::pg_query::DefElem* Node::mutable_def_elem() { ::pg_query::DefElem* _msg = _internal_mutable_def_elem(); // @@protoc_insertion_point(field_mutable:pg_query.Node.def_elem) return _msg; } // .pg_query.RangeTblEntry range_tbl_entry = 196 [json_name = "RangeTblEntry"]; inline bool Node::_internal_has_range_tbl_entry() const { return node_case() == kRangeTblEntry; } inline bool Node::has_range_tbl_entry() const { return _internal_has_range_tbl_entry(); } inline void Node::set_has_range_tbl_entry() { _impl_._oneof_case_[0] = kRangeTblEntry; } inline void Node::clear_range_tbl_entry() { if (_internal_has_range_tbl_entry()) { if (GetArenaForAllocation() == 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 (_internal_has_range_tbl_entry()) { clear_has_node(); ::pg_query::RangeTblEntry* temp = _impl_.node_.range_tbl_entry_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_range_tbl_entry() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.range_tbl_entry) return _internal_range_tbl_entry(); } inline ::pg_query::RangeTblEntry* Node::unsafe_arena_release_range_tbl_entry() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.range_tbl_entry) if (_internal_has_range_tbl_entry()) { clear_has_node(); ::pg_query::RangeTblEntry* temp = _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* range_tbl_entry) { clear_node(); if (range_tbl_entry) { set_has_range_tbl_entry(); _impl_.node_.range_tbl_entry_ = range_tbl_entry; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.range_tbl_entry) } inline ::pg_query::RangeTblEntry* Node::_internal_mutable_range_tbl_entry() { if (!_internal_has_range_tbl_entry()) { clear_node(); set_has_range_tbl_entry(); _impl_.node_.range_tbl_entry_ = CreateMaybeMessage< ::pg_query::RangeTblEntry >(GetArenaForAllocation()); } return _impl_.node_.range_tbl_entry_; } inline ::pg_query::RangeTblEntry* Node::mutable_range_tbl_entry() { ::pg_query::RangeTblEntry* _msg = _internal_mutable_range_tbl_entry(); // @@protoc_insertion_point(field_mutable:pg_query.Node.range_tbl_entry) return _msg; } // .pg_query.RangeTblFunction range_tbl_function = 197 [json_name = "RangeTblFunction"]; inline bool Node::_internal_has_range_tbl_function() const { return node_case() == kRangeTblFunction; } inline bool Node::has_range_tbl_function() const { return _internal_has_range_tbl_function(); } inline void Node::set_has_range_tbl_function() { _impl_._oneof_case_[0] = kRangeTblFunction; } inline void Node::clear_range_tbl_function() { if (_internal_has_range_tbl_function()) { if (GetArenaForAllocation() == 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 (_internal_has_range_tbl_function()) { clear_has_node(); ::pg_query::RangeTblFunction* temp = _impl_.node_.range_tbl_function_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_range_tbl_function() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.range_tbl_function) return _internal_range_tbl_function(); } inline ::pg_query::RangeTblFunction* Node::unsafe_arena_release_range_tbl_function() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.range_tbl_function) if (_internal_has_range_tbl_function()) { clear_has_node(); ::pg_query::RangeTblFunction* temp = _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* range_tbl_function) { clear_node(); if (range_tbl_function) { set_has_range_tbl_function(); _impl_.node_.range_tbl_function_ = range_tbl_function; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.range_tbl_function) } inline ::pg_query::RangeTblFunction* Node::_internal_mutable_range_tbl_function() { if (!_internal_has_range_tbl_function()) { clear_node(); set_has_range_tbl_function(); _impl_.node_.range_tbl_function_ = CreateMaybeMessage< ::pg_query::RangeTblFunction >(GetArenaForAllocation()); } return _impl_.node_.range_tbl_function_; } inline ::pg_query::RangeTblFunction* Node::mutable_range_tbl_function() { ::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 = 198 [json_name = "TableSampleClause"]; inline bool Node::_internal_has_table_sample_clause() const { return node_case() == kTableSampleClause; } inline bool Node::has_table_sample_clause() const { return _internal_has_table_sample_clause(); } inline void Node::set_has_table_sample_clause() { _impl_._oneof_case_[0] = kTableSampleClause; } inline void Node::clear_table_sample_clause() { if (_internal_has_table_sample_clause()) { if (GetArenaForAllocation() == 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 (_internal_has_table_sample_clause()) { clear_has_node(); ::pg_query::TableSampleClause* temp = _impl_.node_.table_sample_clause_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_table_sample_clause() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.table_sample_clause) return _internal_table_sample_clause(); } inline ::pg_query::TableSampleClause* Node::unsafe_arena_release_table_sample_clause() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.table_sample_clause) if (_internal_has_table_sample_clause()) { clear_has_node(); ::pg_query::TableSampleClause* temp = _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* table_sample_clause) { clear_node(); if (table_sample_clause) { set_has_table_sample_clause(); _impl_.node_.table_sample_clause_ = table_sample_clause; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.table_sample_clause) } inline ::pg_query::TableSampleClause* Node::_internal_mutable_table_sample_clause() { if (!_internal_has_table_sample_clause()) { clear_node(); set_has_table_sample_clause(); _impl_.node_.table_sample_clause_ = CreateMaybeMessage< ::pg_query::TableSampleClause >(GetArenaForAllocation()); } return _impl_.node_.table_sample_clause_; } inline ::pg_query::TableSampleClause* Node::mutable_table_sample_clause() { ::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 = 199 [json_name = "WithCheckOption"]; inline bool Node::_internal_has_with_check_option() const { return node_case() == kWithCheckOption; } inline bool Node::has_with_check_option() const { return _internal_has_with_check_option(); } inline void Node::set_has_with_check_option() { _impl_._oneof_case_[0] = kWithCheckOption; } inline void Node::clear_with_check_option() { if (_internal_has_with_check_option()) { if (GetArenaForAllocation() == 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 (_internal_has_with_check_option()) { clear_has_node(); ::pg_query::WithCheckOption* temp = _impl_.node_.with_check_option_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_with_check_option() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.with_check_option) return _internal_with_check_option(); } inline ::pg_query::WithCheckOption* Node::unsafe_arena_release_with_check_option() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.with_check_option) if (_internal_has_with_check_option()) { clear_has_node(); ::pg_query::WithCheckOption* temp = _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* with_check_option) { clear_node(); if (with_check_option) { set_has_with_check_option(); _impl_.node_.with_check_option_ = with_check_option; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.with_check_option) } inline ::pg_query::WithCheckOption* Node::_internal_mutable_with_check_option() { if (!_internal_has_with_check_option()) { clear_node(); set_has_with_check_option(); _impl_.node_.with_check_option_ = CreateMaybeMessage< ::pg_query::WithCheckOption >(GetArenaForAllocation()); } return _impl_.node_.with_check_option_; } inline ::pg_query::WithCheckOption* Node::mutable_with_check_option() { ::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 = 200 [json_name = "SortGroupClause"]; inline bool Node::_internal_has_sort_group_clause() const { return node_case() == kSortGroupClause; } inline bool Node::has_sort_group_clause() const { return _internal_has_sort_group_clause(); } inline void Node::set_has_sort_group_clause() { _impl_._oneof_case_[0] = kSortGroupClause; } inline void Node::clear_sort_group_clause() { if (_internal_has_sort_group_clause()) { if (GetArenaForAllocation() == 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 (_internal_has_sort_group_clause()) { clear_has_node(); ::pg_query::SortGroupClause* temp = _impl_.node_.sort_group_clause_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_sort_group_clause() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.sort_group_clause) return _internal_sort_group_clause(); } inline ::pg_query::SortGroupClause* Node::unsafe_arena_release_sort_group_clause() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.sort_group_clause) if (_internal_has_sort_group_clause()) { clear_has_node(); ::pg_query::SortGroupClause* temp = _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* sort_group_clause) { clear_node(); if (sort_group_clause) { set_has_sort_group_clause(); _impl_.node_.sort_group_clause_ = sort_group_clause; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.sort_group_clause) } inline ::pg_query::SortGroupClause* Node::_internal_mutable_sort_group_clause() { if (!_internal_has_sort_group_clause()) { clear_node(); set_has_sort_group_clause(); _impl_.node_.sort_group_clause_ = CreateMaybeMessage< ::pg_query::SortGroupClause >(GetArenaForAllocation()); } return _impl_.node_.sort_group_clause_; } inline ::pg_query::SortGroupClause* Node::mutable_sort_group_clause() { ::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 = 201 [json_name = "GroupingSet"]; inline bool Node::_internal_has_grouping_set() const { return node_case() == kGroupingSet; } inline bool Node::has_grouping_set() const { return _internal_has_grouping_set(); } inline void Node::set_has_grouping_set() { _impl_._oneof_case_[0] = kGroupingSet; } inline void Node::clear_grouping_set() { if (_internal_has_grouping_set()) { if (GetArenaForAllocation() == 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 (_internal_has_grouping_set()) { clear_has_node(); ::pg_query::GroupingSet* temp = _impl_.node_.grouping_set_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.grouping_set_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::GroupingSet& Node::_internal_grouping_set() const { return _internal_has_grouping_set() ? *_impl_.node_.grouping_set_ : reinterpret_cast< ::pg_query::GroupingSet&>(::pg_query::_GroupingSet_default_instance_); } inline const ::pg_query::GroupingSet& Node::grouping_set() const { // @@protoc_insertion_point(field_get:pg_query.Node.grouping_set) return _internal_grouping_set(); } inline ::pg_query::GroupingSet* Node::unsafe_arena_release_grouping_set() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.grouping_set) if (_internal_has_grouping_set()) { clear_has_node(); ::pg_query::GroupingSet* temp = _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* grouping_set) { clear_node(); if (grouping_set) { set_has_grouping_set(); _impl_.node_.grouping_set_ = grouping_set; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.grouping_set) } inline ::pg_query::GroupingSet* Node::_internal_mutable_grouping_set() { if (!_internal_has_grouping_set()) { clear_node(); set_has_grouping_set(); _impl_.node_.grouping_set_ = CreateMaybeMessage< ::pg_query::GroupingSet >(GetArenaForAllocation()); } return _impl_.node_.grouping_set_; } inline ::pg_query::GroupingSet* Node::mutable_grouping_set() { ::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 = 202 [json_name = "WindowClause"]; inline bool Node::_internal_has_window_clause() const { return node_case() == kWindowClause; } inline bool Node::has_window_clause() const { return _internal_has_window_clause(); } inline void Node::set_has_window_clause() { _impl_._oneof_case_[0] = kWindowClause; } inline void Node::clear_window_clause() { if (_internal_has_window_clause()) { if (GetArenaForAllocation() == 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 (_internal_has_window_clause()) { clear_has_node(); ::pg_query::WindowClause* temp = _impl_.node_.window_clause_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.window_clause_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::WindowClause& Node::_internal_window_clause() const { return _internal_has_window_clause() ? *_impl_.node_.window_clause_ : reinterpret_cast< ::pg_query::WindowClause&>(::pg_query::_WindowClause_default_instance_); } inline const ::pg_query::WindowClause& Node::window_clause() const { // @@protoc_insertion_point(field_get:pg_query.Node.window_clause) return _internal_window_clause(); } inline ::pg_query::WindowClause* Node::unsafe_arena_release_window_clause() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.window_clause) if (_internal_has_window_clause()) { clear_has_node(); ::pg_query::WindowClause* temp = _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* window_clause) { clear_node(); if (window_clause) { set_has_window_clause(); _impl_.node_.window_clause_ = window_clause; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.window_clause) } inline ::pg_query::WindowClause* Node::_internal_mutable_window_clause() { if (!_internal_has_window_clause()) { clear_node(); set_has_window_clause(); _impl_.node_.window_clause_ = CreateMaybeMessage< ::pg_query::WindowClause >(GetArenaForAllocation()); } return _impl_.node_.window_clause_; } inline ::pg_query::WindowClause* Node::mutable_window_clause() { ::pg_query::WindowClause* _msg = _internal_mutable_window_clause(); // @@protoc_insertion_point(field_mutable:pg_query.Node.window_clause) return _msg; } // .pg_query.ObjectWithArgs object_with_args = 203 [json_name = "ObjectWithArgs"]; inline bool Node::_internal_has_object_with_args() const { return node_case() == kObjectWithArgs; } inline bool Node::has_object_with_args() const { return _internal_has_object_with_args(); } inline void Node::set_has_object_with_args() { _impl_._oneof_case_[0] = kObjectWithArgs; } inline void Node::clear_object_with_args() { if (_internal_has_object_with_args()) { if (GetArenaForAllocation() == 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 (_internal_has_object_with_args()) { clear_has_node(); ::pg_query::ObjectWithArgs* temp = _impl_.node_.object_with_args_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_object_with_args() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.object_with_args) return _internal_object_with_args(); } inline ::pg_query::ObjectWithArgs* Node::unsafe_arena_release_object_with_args() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.object_with_args) if (_internal_has_object_with_args()) { clear_has_node(); ::pg_query::ObjectWithArgs* temp = _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* object_with_args) { clear_node(); if (object_with_args) { set_has_object_with_args(); _impl_.node_.object_with_args_ = object_with_args; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.object_with_args) } inline ::pg_query::ObjectWithArgs* Node::_internal_mutable_object_with_args() { if (!_internal_has_object_with_args()) { clear_node(); set_has_object_with_args(); _impl_.node_.object_with_args_ = CreateMaybeMessage< ::pg_query::ObjectWithArgs >(GetArenaForAllocation()); } return _impl_.node_.object_with_args_; } inline ::pg_query::ObjectWithArgs* Node::mutable_object_with_args() { ::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 = 204 [json_name = "AccessPriv"]; inline bool Node::_internal_has_access_priv() const { return node_case() == kAccessPriv; } inline bool Node::has_access_priv() const { return _internal_has_access_priv(); } inline void Node::set_has_access_priv() { _impl_._oneof_case_[0] = kAccessPriv; } inline void Node::clear_access_priv() { if (_internal_has_access_priv()) { if (GetArenaForAllocation() == 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 (_internal_has_access_priv()) { clear_has_node(); ::pg_query::AccessPriv* temp = _impl_.node_.access_priv_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.access_priv_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::AccessPriv& Node::_internal_access_priv() const { return _internal_has_access_priv() ? *_impl_.node_.access_priv_ : reinterpret_cast< ::pg_query::AccessPriv&>(::pg_query::_AccessPriv_default_instance_); } inline const ::pg_query::AccessPriv& Node::access_priv() const { // @@protoc_insertion_point(field_get:pg_query.Node.access_priv) return _internal_access_priv(); } inline ::pg_query::AccessPriv* Node::unsafe_arena_release_access_priv() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.access_priv) if (_internal_has_access_priv()) { clear_has_node(); ::pg_query::AccessPriv* temp = _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* access_priv) { clear_node(); if (access_priv) { set_has_access_priv(); _impl_.node_.access_priv_ = access_priv; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.access_priv) } inline ::pg_query::AccessPriv* Node::_internal_mutable_access_priv() { if (!_internal_has_access_priv()) { clear_node(); set_has_access_priv(); _impl_.node_.access_priv_ = CreateMaybeMessage< ::pg_query::AccessPriv >(GetArenaForAllocation()); } return _impl_.node_.access_priv_; } inline ::pg_query::AccessPriv* Node::mutable_access_priv() { ::pg_query::AccessPriv* _msg = _internal_mutable_access_priv(); // @@protoc_insertion_point(field_mutable:pg_query.Node.access_priv) return _msg; } // .pg_query.CreateOpClassItem create_op_class_item = 205 [json_name = "CreateOpClassItem"]; inline bool Node::_internal_has_create_op_class_item() const { return node_case() == kCreateOpClassItem; } inline bool Node::has_create_op_class_item() const { return _internal_has_create_op_class_item(); } inline void Node::set_has_create_op_class_item() { _impl_._oneof_case_[0] = kCreateOpClassItem; } inline void Node::clear_create_op_class_item() { if (_internal_has_create_op_class_item()) { if (GetArenaForAllocation() == 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 (_internal_has_create_op_class_item()) { clear_has_node(); ::pg_query::CreateOpClassItem* temp = _impl_.node_.create_op_class_item_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_create_op_class_item() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.create_op_class_item) return _internal_create_op_class_item(); } inline ::pg_query::CreateOpClassItem* Node::unsafe_arena_release_create_op_class_item() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.create_op_class_item) if (_internal_has_create_op_class_item()) { clear_has_node(); ::pg_query::CreateOpClassItem* temp = _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* create_op_class_item) { clear_node(); if (create_op_class_item) { set_has_create_op_class_item(); _impl_.node_.create_op_class_item_ = create_op_class_item; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.create_op_class_item) } inline ::pg_query::CreateOpClassItem* Node::_internal_mutable_create_op_class_item() { if (!_internal_has_create_op_class_item()) { clear_node(); set_has_create_op_class_item(); _impl_.node_.create_op_class_item_ = CreateMaybeMessage< ::pg_query::CreateOpClassItem >(GetArenaForAllocation()); } return _impl_.node_.create_op_class_item_; } inline ::pg_query::CreateOpClassItem* Node::mutable_create_op_class_item() { ::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.TableLikeClause table_like_clause = 206 [json_name = "TableLikeClause"]; inline bool Node::_internal_has_table_like_clause() const { return node_case() == kTableLikeClause; } inline bool Node::has_table_like_clause() const { return _internal_has_table_like_clause(); } inline void Node::set_has_table_like_clause() { _impl_._oneof_case_[0] = kTableLikeClause; } inline void Node::clear_table_like_clause() { if (_internal_has_table_like_clause()) { if (GetArenaForAllocation() == 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 (_internal_has_table_like_clause()) { clear_has_node(); ::pg_query::TableLikeClause* temp = _impl_.node_.table_like_clause_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_table_like_clause() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.table_like_clause) return _internal_table_like_clause(); } inline ::pg_query::TableLikeClause* Node::unsafe_arena_release_table_like_clause() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.table_like_clause) if (_internal_has_table_like_clause()) { clear_has_node(); ::pg_query::TableLikeClause* temp = _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* table_like_clause) { clear_node(); if (table_like_clause) { set_has_table_like_clause(); _impl_.node_.table_like_clause_ = table_like_clause; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.table_like_clause) } inline ::pg_query::TableLikeClause* Node::_internal_mutable_table_like_clause() { if (!_internal_has_table_like_clause()) { clear_node(); set_has_table_like_clause(); _impl_.node_.table_like_clause_ = CreateMaybeMessage< ::pg_query::TableLikeClause >(GetArenaForAllocation()); } return _impl_.node_.table_like_clause_; } inline ::pg_query::TableLikeClause* Node::mutable_table_like_clause() { ::pg_query::TableLikeClause* _msg = _internal_mutable_table_like_clause(); // @@protoc_insertion_point(field_mutable:pg_query.Node.table_like_clause) return _msg; } // .pg_query.FunctionParameter function_parameter = 207 [json_name = "FunctionParameter"]; inline bool Node::_internal_has_function_parameter() const { return node_case() == kFunctionParameter; } inline bool Node::has_function_parameter() const { return _internal_has_function_parameter(); } inline void Node::set_has_function_parameter() { _impl_._oneof_case_[0] = kFunctionParameter; } inline void Node::clear_function_parameter() { if (_internal_has_function_parameter()) { if (GetArenaForAllocation() == 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 (_internal_has_function_parameter()) { clear_has_node(); ::pg_query::FunctionParameter* temp = _impl_.node_.function_parameter_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.function_parameter_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::FunctionParameter& Node::_internal_function_parameter() const { return _internal_has_function_parameter() ? *_impl_.node_.function_parameter_ : reinterpret_cast< ::pg_query::FunctionParameter&>(::pg_query::_FunctionParameter_default_instance_); } inline const ::pg_query::FunctionParameter& Node::function_parameter() const { // @@protoc_insertion_point(field_get:pg_query.Node.function_parameter) return _internal_function_parameter(); } inline ::pg_query::FunctionParameter* Node::unsafe_arena_release_function_parameter() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.function_parameter) if (_internal_has_function_parameter()) { clear_has_node(); ::pg_query::FunctionParameter* temp = _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* function_parameter) { clear_node(); if (function_parameter) { set_has_function_parameter(); _impl_.node_.function_parameter_ = function_parameter; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.function_parameter) } inline ::pg_query::FunctionParameter* Node::_internal_mutable_function_parameter() { if (!_internal_has_function_parameter()) { clear_node(); set_has_function_parameter(); _impl_.node_.function_parameter_ = CreateMaybeMessage< ::pg_query::FunctionParameter >(GetArenaForAllocation()); } return _impl_.node_.function_parameter_; } inline ::pg_query::FunctionParameter* Node::mutable_function_parameter() { ::pg_query::FunctionParameter* _msg = _internal_mutable_function_parameter(); // @@protoc_insertion_point(field_mutable:pg_query.Node.function_parameter) return _msg; } // .pg_query.LockingClause locking_clause = 208 [json_name = "LockingClause"]; inline bool Node::_internal_has_locking_clause() const { return node_case() == kLockingClause; } inline bool Node::has_locking_clause() const { return _internal_has_locking_clause(); } inline void Node::set_has_locking_clause() { _impl_._oneof_case_[0] = kLockingClause; } inline void Node::clear_locking_clause() { if (_internal_has_locking_clause()) { if (GetArenaForAllocation() == 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 (_internal_has_locking_clause()) { clear_has_node(); ::pg_query::LockingClause* temp = _impl_.node_.locking_clause_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.locking_clause_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::LockingClause& Node::_internal_locking_clause() const { return _internal_has_locking_clause() ? *_impl_.node_.locking_clause_ : reinterpret_cast< ::pg_query::LockingClause&>(::pg_query::_LockingClause_default_instance_); } inline const ::pg_query::LockingClause& Node::locking_clause() const { // @@protoc_insertion_point(field_get:pg_query.Node.locking_clause) return _internal_locking_clause(); } inline ::pg_query::LockingClause* Node::unsafe_arena_release_locking_clause() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.locking_clause) if (_internal_has_locking_clause()) { clear_has_node(); ::pg_query::LockingClause* temp = _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* locking_clause) { clear_node(); if (locking_clause) { set_has_locking_clause(); _impl_.node_.locking_clause_ = locking_clause; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.locking_clause) } inline ::pg_query::LockingClause* Node::_internal_mutable_locking_clause() { if (!_internal_has_locking_clause()) { clear_node(); set_has_locking_clause(); _impl_.node_.locking_clause_ = CreateMaybeMessage< ::pg_query::LockingClause >(GetArenaForAllocation()); } return _impl_.node_.locking_clause_; } inline ::pg_query::LockingClause* Node::mutable_locking_clause() { ::pg_query::LockingClause* _msg = _internal_mutable_locking_clause(); // @@protoc_insertion_point(field_mutable:pg_query.Node.locking_clause) return _msg; } // .pg_query.RowMarkClause row_mark_clause = 209 [json_name = "RowMarkClause"]; inline bool Node::_internal_has_row_mark_clause() const { return node_case() == kRowMarkClause; } inline bool Node::has_row_mark_clause() const { return _internal_has_row_mark_clause(); } inline void Node::set_has_row_mark_clause() { _impl_._oneof_case_[0] = kRowMarkClause; } inline void Node::clear_row_mark_clause() { if (_internal_has_row_mark_clause()) { if (GetArenaForAllocation() == 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 (_internal_has_row_mark_clause()) { clear_has_node(); ::pg_query::RowMarkClause* temp = _impl_.node_.row_mark_clause_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_row_mark_clause() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.row_mark_clause) return _internal_row_mark_clause(); } inline ::pg_query::RowMarkClause* Node::unsafe_arena_release_row_mark_clause() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.row_mark_clause) if (_internal_has_row_mark_clause()) { clear_has_node(); ::pg_query::RowMarkClause* temp = _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* row_mark_clause) { clear_node(); if (row_mark_clause) { set_has_row_mark_clause(); _impl_.node_.row_mark_clause_ = row_mark_clause; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.row_mark_clause) } inline ::pg_query::RowMarkClause* Node::_internal_mutable_row_mark_clause() { if (!_internal_has_row_mark_clause()) { clear_node(); set_has_row_mark_clause(); _impl_.node_.row_mark_clause_ = CreateMaybeMessage< ::pg_query::RowMarkClause >(GetArenaForAllocation()); } return _impl_.node_.row_mark_clause_; } inline ::pg_query::RowMarkClause* Node::mutable_row_mark_clause() { ::pg_query::RowMarkClause* _msg = _internal_mutable_row_mark_clause(); // @@protoc_insertion_point(field_mutable:pg_query.Node.row_mark_clause) return _msg; } // .pg_query.XmlSerialize xml_serialize = 210 [json_name = "XmlSerialize"]; inline bool Node::_internal_has_xml_serialize() const { return node_case() == kXmlSerialize; } inline bool Node::has_xml_serialize() const { return _internal_has_xml_serialize(); } inline void Node::set_has_xml_serialize() { _impl_._oneof_case_[0] = kXmlSerialize; } inline void Node::clear_xml_serialize() { if (_internal_has_xml_serialize()) { if (GetArenaForAllocation() == 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 (_internal_has_xml_serialize()) { clear_has_node(); ::pg_query::XmlSerialize* temp = _impl_.node_.xml_serialize_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.xml_serialize_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::XmlSerialize& Node::_internal_xml_serialize() const { return _internal_has_xml_serialize() ? *_impl_.node_.xml_serialize_ : reinterpret_cast< ::pg_query::XmlSerialize&>(::pg_query::_XmlSerialize_default_instance_); } inline const ::pg_query::XmlSerialize& Node::xml_serialize() const { // @@protoc_insertion_point(field_get:pg_query.Node.xml_serialize) return _internal_xml_serialize(); } inline ::pg_query::XmlSerialize* Node::unsafe_arena_release_xml_serialize() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.xml_serialize) if (_internal_has_xml_serialize()) { clear_has_node(); ::pg_query::XmlSerialize* temp = _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* xml_serialize) { clear_node(); if (xml_serialize) { set_has_xml_serialize(); _impl_.node_.xml_serialize_ = xml_serialize; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.xml_serialize) } inline ::pg_query::XmlSerialize* Node::_internal_mutable_xml_serialize() { if (!_internal_has_xml_serialize()) { clear_node(); set_has_xml_serialize(); _impl_.node_.xml_serialize_ = CreateMaybeMessage< ::pg_query::XmlSerialize >(GetArenaForAllocation()); } return _impl_.node_.xml_serialize_; } inline ::pg_query::XmlSerialize* Node::mutable_xml_serialize() { ::pg_query::XmlSerialize* _msg = _internal_mutable_xml_serialize(); // @@protoc_insertion_point(field_mutable:pg_query.Node.xml_serialize) return _msg; } // .pg_query.WithClause with_clause = 211 [json_name = "WithClause"]; inline bool Node::_internal_has_with_clause() const { return node_case() == kWithClause; } inline bool Node::has_with_clause() const { return _internal_has_with_clause(); } inline void Node::set_has_with_clause() { _impl_._oneof_case_[0] = kWithClause; } inline void Node::clear_with_clause() { if (_internal_has_with_clause()) { if (GetArenaForAllocation() == 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 (_internal_has_with_clause()) { clear_has_node(); ::pg_query::WithClause* temp = _impl_.node_.with_clause_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.with_clause_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::WithClause& Node::_internal_with_clause() const { return _internal_has_with_clause() ? *_impl_.node_.with_clause_ : reinterpret_cast< ::pg_query::WithClause&>(::pg_query::_WithClause_default_instance_); } inline const ::pg_query::WithClause& Node::with_clause() const { // @@protoc_insertion_point(field_get:pg_query.Node.with_clause) return _internal_with_clause(); } inline ::pg_query::WithClause* Node::unsafe_arena_release_with_clause() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.with_clause) if (_internal_has_with_clause()) { clear_has_node(); ::pg_query::WithClause* temp = _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* with_clause) { clear_node(); if (with_clause) { set_has_with_clause(); _impl_.node_.with_clause_ = with_clause; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.with_clause) } inline ::pg_query::WithClause* Node::_internal_mutable_with_clause() { if (!_internal_has_with_clause()) { clear_node(); set_has_with_clause(); _impl_.node_.with_clause_ = CreateMaybeMessage< ::pg_query::WithClause >(GetArenaForAllocation()); } return _impl_.node_.with_clause_; } inline ::pg_query::WithClause* Node::mutable_with_clause() { ::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 = 212 [json_name = "InferClause"]; inline bool Node::_internal_has_infer_clause() const { return node_case() == kInferClause; } inline bool Node::has_infer_clause() const { return _internal_has_infer_clause(); } inline void Node::set_has_infer_clause() { _impl_._oneof_case_[0] = kInferClause; } inline void Node::clear_infer_clause() { if (_internal_has_infer_clause()) { if (GetArenaForAllocation() == 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 (_internal_has_infer_clause()) { clear_has_node(); ::pg_query::InferClause* temp = _impl_.node_.infer_clause_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.infer_clause_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::InferClause& Node::_internal_infer_clause() const { return _internal_has_infer_clause() ? *_impl_.node_.infer_clause_ : reinterpret_cast< ::pg_query::InferClause&>(::pg_query::_InferClause_default_instance_); } inline const ::pg_query::InferClause& Node::infer_clause() const { // @@protoc_insertion_point(field_get:pg_query.Node.infer_clause) return _internal_infer_clause(); } inline ::pg_query::InferClause* Node::unsafe_arena_release_infer_clause() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.infer_clause) if (_internal_has_infer_clause()) { clear_has_node(); ::pg_query::InferClause* temp = _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* infer_clause) { clear_node(); if (infer_clause) { set_has_infer_clause(); _impl_.node_.infer_clause_ = infer_clause; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.infer_clause) } inline ::pg_query::InferClause* Node::_internal_mutable_infer_clause() { if (!_internal_has_infer_clause()) { clear_node(); set_has_infer_clause(); _impl_.node_.infer_clause_ = CreateMaybeMessage< ::pg_query::InferClause >(GetArenaForAllocation()); } return _impl_.node_.infer_clause_; } inline ::pg_query::InferClause* Node::mutable_infer_clause() { ::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 = 213 [json_name = "OnConflictClause"]; inline bool Node::_internal_has_on_conflict_clause() const { return node_case() == kOnConflictClause; } inline bool Node::has_on_conflict_clause() const { return _internal_has_on_conflict_clause(); } inline void Node::set_has_on_conflict_clause() { _impl_._oneof_case_[0] = kOnConflictClause; } inline void Node::clear_on_conflict_clause() { if (_internal_has_on_conflict_clause()) { if (GetArenaForAllocation() == 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 (_internal_has_on_conflict_clause()) { clear_has_node(); ::pg_query::OnConflictClause* temp = _impl_.node_.on_conflict_clause_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_on_conflict_clause() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.on_conflict_clause) return _internal_on_conflict_clause(); } inline ::pg_query::OnConflictClause* Node::unsafe_arena_release_on_conflict_clause() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.on_conflict_clause) if (_internal_has_on_conflict_clause()) { clear_has_node(); ::pg_query::OnConflictClause* temp = _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* on_conflict_clause) { clear_node(); if (on_conflict_clause) { set_has_on_conflict_clause(); _impl_.node_.on_conflict_clause_ = on_conflict_clause; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.on_conflict_clause) } inline ::pg_query::OnConflictClause* Node::_internal_mutable_on_conflict_clause() { if (!_internal_has_on_conflict_clause()) { clear_node(); set_has_on_conflict_clause(); _impl_.node_.on_conflict_clause_ = CreateMaybeMessage< ::pg_query::OnConflictClause >(GetArenaForAllocation()); } return _impl_.node_.on_conflict_clause_; } inline ::pg_query::OnConflictClause* Node::mutable_on_conflict_clause() { ::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 = 214 [json_name = "CTESearchClause"]; inline bool Node::_internal_has_ctesearch_clause() const { return node_case() == kCtesearchClause; } inline bool Node::has_ctesearch_clause() const { return _internal_has_ctesearch_clause(); } inline void Node::set_has_ctesearch_clause() { _impl_._oneof_case_[0] = kCtesearchClause; } inline void Node::clear_ctesearch_clause() { if (_internal_has_ctesearch_clause()) { if (GetArenaForAllocation() == 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 (_internal_has_ctesearch_clause()) { clear_has_node(); ::pg_query::CTESearchClause* temp = _impl_.node_.ctesearch_clause_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.ctesearch_clause_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::CTESearchClause& Node::_internal_ctesearch_clause() const { return _internal_has_ctesearch_clause() ? *_impl_.node_.ctesearch_clause_ : reinterpret_cast< ::pg_query::CTESearchClause&>(::pg_query::_CTESearchClause_default_instance_); } inline const ::pg_query::CTESearchClause& Node::ctesearch_clause() const { // @@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 (_internal_has_ctesearch_clause()) { clear_has_node(); ::pg_query::CTESearchClause* 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* ctesearch_clause) { clear_node(); if (ctesearch_clause) { set_has_ctesearch_clause(); _impl_.node_.ctesearch_clause_ = ctesearch_clause; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.ctesearch_clause) } inline ::pg_query::CTESearchClause* Node::_internal_mutable_ctesearch_clause() { if (!_internal_has_ctesearch_clause()) { clear_node(); set_has_ctesearch_clause(); _impl_.node_.ctesearch_clause_ = CreateMaybeMessage< ::pg_query::CTESearchClause >(GetArenaForAllocation()); } return _impl_.node_.ctesearch_clause_; } inline ::pg_query::CTESearchClause* Node::mutable_ctesearch_clause() { ::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 = 215 [json_name = "CTECycleClause"]; inline bool Node::_internal_has_ctecycle_clause() const { return node_case() == kCtecycleClause; } inline bool Node::has_ctecycle_clause() const { return _internal_has_ctecycle_clause(); } inline void Node::set_has_ctecycle_clause() { _impl_._oneof_case_[0] = kCtecycleClause; } inline void Node::clear_ctecycle_clause() { if (_internal_has_ctecycle_clause()) { if (GetArenaForAllocation() == 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 (_internal_has_ctecycle_clause()) { clear_has_node(); ::pg_query::CTECycleClause* temp = _impl_.node_.ctecycle_clause_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.ctecycle_clause_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::CTECycleClause& Node::_internal_ctecycle_clause() const { return _internal_has_ctecycle_clause() ? *_impl_.node_.ctecycle_clause_ : reinterpret_cast< ::pg_query::CTECycleClause&>(::pg_query::_CTECycleClause_default_instance_); } inline const ::pg_query::CTECycleClause& Node::ctecycle_clause() const { // @@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 (_internal_has_ctecycle_clause()) { clear_has_node(); ::pg_query::CTECycleClause* 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* ctecycle_clause) { clear_node(); if (ctecycle_clause) { set_has_ctecycle_clause(); _impl_.node_.ctecycle_clause_ = ctecycle_clause; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.ctecycle_clause) } inline ::pg_query::CTECycleClause* Node::_internal_mutable_ctecycle_clause() { if (!_internal_has_ctecycle_clause()) { clear_node(); set_has_ctecycle_clause(); _impl_.node_.ctecycle_clause_ = CreateMaybeMessage< ::pg_query::CTECycleClause >(GetArenaForAllocation()); } return _impl_.node_.ctecycle_clause_; } inline ::pg_query::CTECycleClause* Node::mutable_ctecycle_clause() { ::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 = 216 [json_name = "CommonTableExpr"]; inline bool Node::_internal_has_common_table_expr() const { return node_case() == kCommonTableExpr; } inline bool Node::has_common_table_expr() const { return _internal_has_common_table_expr(); } inline void Node::set_has_common_table_expr() { _impl_._oneof_case_[0] = kCommonTableExpr; } inline void Node::clear_common_table_expr() { if (_internal_has_common_table_expr()) { if (GetArenaForAllocation() == 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 (_internal_has_common_table_expr()) { clear_has_node(); ::pg_query::CommonTableExpr* temp = _impl_.node_.common_table_expr_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_common_table_expr() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.common_table_expr) return _internal_common_table_expr(); } inline ::pg_query::CommonTableExpr* Node::unsafe_arena_release_common_table_expr() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.common_table_expr) if (_internal_has_common_table_expr()) { clear_has_node(); ::pg_query::CommonTableExpr* temp = _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* common_table_expr) { clear_node(); if (common_table_expr) { set_has_common_table_expr(); _impl_.node_.common_table_expr_ = common_table_expr; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.common_table_expr) } inline ::pg_query::CommonTableExpr* Node::_internal_mutable_common_table_expr() { if (!_internal_has_common_table_expr()) { clear_node(); set_has_common_table_expr(); _impl_.node_.common_table_expr_ = CreateMaybeMessage< ::pg_query::CommonTableExpr >(GetArenaForAllocation()); } return _impl_.node_.common_table_expr_; } inline ::pg_query::CommonTableExpr* Node::mutable_common_table_expr() { ::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 = 217 [json_name = "MergeWhenClause"]; inline bool Node::_internal_has_merge_when_clause() const { return node_case() == kMergeWhenClause; } inline bool Node::has_merge_when_clause() const { return _internal_has_merge_when_clause(); } inline void Node::set_has_merge_when_clause() { _impl_._oneof_case_[0] = kMergeWhenClause; } inline void Node::clear_merge_when_clause() { if (_internal_has_merge_when_clause()) { if (GetArenaForAllocation() == 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 (_internal_has_merge_when_clause()) { clear_has_node(); ::pg_query::MergeWhenClause* temp = _impl_.node_.merge_when_clause_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_merge_when_clause() ? *_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 { // @@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 (_internal_has_merge_when_clause()) { clear_has_node(); ::pg_query::MergeWhenClause* 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* merge_when_clause) { clear_node(); if (merge_when_clause) { set_has_merge_when_clause(); _impl_.node_.merge_when_clause_ = merge_when_clause; } // @@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 (!_internal_has_merge_when_clause()) { clear_node(); set_has_merge_when_clause(); _impl_.node_.merge_when_clause_ = CreateMaybeMessage< ::pg_query::MergeWhenClause >(GetArenaForAllocation()); } return _impl_.node_.merge_when_clause_; } inline ::pg_query::MergeWhenClause* Node::mutable_merge_when_clause() { ::pg_query::MergeWhenClause* _msg = _internal_mutable_merge_when_clause(); // @@protoc_insertion_point(field_mutable:pg_query.Node.merge_when_clause) return _msg; } // .pg_query.RoleSpec role_spec = 218 [json_name = "RoleSpec"]; inline bool Node::_internal_has_role_spec() const { return node_case() == kRoleSpec; } inline bool Node::has_role_spec() const { return _internal_has_role_spec(); } inline void Node::set_has_role_spec() { _impl_._oneof_case_[0] = kRoleSpec; } inline void Node::clear_role_spec() { if (_internal_has_role_spec()) { if (GetArenaForAllocation() == 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 (_internal_has_role_spec()) { clear_has_node(); ::pg_query::RoleSpec* temp = _impl_.node_.role_spec_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.role_spec_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::RoleSpec& Node::_internal_role_spec() const { return _internal_has_role_spec() ? *_impl_.node_.role_spec_ : reinterpret_cast< ::pg_query::RoleSpec&>(::pg_query::_RoleSpec_default_instance_); } inline const ::pg_query::RoleSpec& Node::role_spec() const { // @@protoc_insertion_point(field_get:pg_query.Node.role_spec) return _internal_role_spec(); } inline ::pg_query::RoleSpec* Node::unsafe_arena_release_role_spec() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.role_spec) if (_internal_has_role_spec()) { clear_has_node(); ::pg_query::RoleSpec* temp = _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* role_spec) { clear_node(); if (role_spec) { set_has_role_spec(); _impl_.node_.role_spec_ = role_spec; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.role_spec) } inline ::pg_query::RoleSpec* Node::_internal_mutable_role_spec() { if (!_internal_has_role_spec()) { clear_node(); set_has_role_spec(); _impl_.node_.role_spec_ = CreateMaybeMessage< ::pg_query::RoleSpec >(GetArenaForAllocation()); } return _impl_.node_.role_spec_; } inline ::pg_query::RoleSpec* Node::mutable_role_spec() { ::pg_query::RoleSpec* _msg = _internal_mutable_role_spec(); // @@protoc_insertion_point(field_mutable:pg_query.Node.role_spec) return _msg; } // .pg_query.TriggerTransition trigger_transition = 219 [json_name = "TriggerTransition"]; inline bool Node::_internal_has_trigger_transition() const { return node_case() == kTriggerTransition; } inline bool Node::has_trigger_transition() const { return _internal_has_trigger_transition(); } inline void Node::set_has_trigger_transition() { _impl_._oneof_case_[0] = kTriggerTransition; } inline void Node::clear_trigger_transition() { if (_internal_has_trigger_transition()) { if (GetArenaForAllocation() == 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 (_internal_has_trigger_transition()) { clear_has_node(); ::pg_query::TriggerTransition* temp = _impl_.node_.trigger_transition_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.trigger_transition_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::TriggerTransition& Node::_internal_trigger_transition() const { return _internal_has_trigger_transition() ? *_impl_.node_.trigger_transition_ : reinterpret_cast< ::pg_query::TriggerTransition&>(::pg_query::_TriggerTransition_default_instance_); } inline const ::pg_query::TriggerTransition& Node::trigger_transition() const { // @@protoc_insertion_point(field_get:pg_query.Node.trigger_transition) return _internal_trigger_transition(); } inline ::pg_query::TriggerTransition* Node::unsafe_arena_release_trigger_transition() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.trigger_transition) if (_internal_has_trigger_transition()) { clear_has_node(); ::pg_query::TriggerTransition* temp = _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* trigger_transition) { clear_node(); if (trigger_transition) { set_has_trigger_transition(); _impl_.node_.trigger_transition_ = trigger_transition; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.trigger_transition) } inline ::pg_query::TriggerTransition* Node::_internal_mutable_trigger_transition() { if (!_internal_has_trigger_transition()) { clear_node(); set_has_trigger_transition(); _impl_.node_.trigger_transition_ = CreateMaybeMessage< ::pg_query::TriggerTransition >(GetArenaForAllocation()); } return _impl_.node_.trigger_transition_; } inline ::pg_query::TriggerTransition* Node::mutable_trigger_transition() { ::pg_query::TriggerTransition* _msg = _internal_mutable_trigger_transition(); // @@protoc_insertion_point(field_mutable:pg_query.Node.trigger_transition) return _msg; } // .pg_query.PartitionElem partition_elem = 220 [json_name = "PartitionElem"]; inline bool Node::_internal_has_partition_elem() const { return node_case() == kPartitionElem; } inline bool Node::has_partition_elem() const { return _internal_has_partition_elem(); } inline void Node::set_has_partition_elem() { _impl_._oneof_case_[0] = kPartitionElem; } inline void Node::clear_partition_elem() { if (_internal_has_partition_elem()) { if (GetArenaForAllocation() == 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 (_internal_has_partition_elem()) { clear_has_node(); ::pg_query::PartitionElem* temp = _impl_.node_.partition_elem_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.partition_elem_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::PartitionElem& Node::_internal_partition_elem() const { return _internal_has_partition_elem() ? *_impl_.node_.partition_elem_ : reinterpret_cast< ::pg_query::PartitionElem&>(::pg_query::_PartitionElem_default_instance_); } inline const ::pg_query::PartitionElem& Node::partition_elem() const { // @@protoc_insertion_point(field_get:pg_query.Node.partition_elem) return _internal_partition_elem(); } inline ::pg_query::PartitionElem* Node::unsafe_arena_release_partition_elem() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.partition_elem) if (_internal_has_partition_elem()) { clear_has_node(); ::pg_query::PartitionElem* temp = _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* partition_elem) { clear_node(); if (partition_elem) { set_has_partition_elem(); _impl_.node_.partition_elem_ = partition_elem; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.partition_elem) } inline ::pg_query::PartitionElem* Node::_internal_mutable_partition_elem() { if (!_internal_has_partition_elem()) { clear_node(); set_has_partition_elem(); _impl_.node_.partition_elem_ = CreateMaybeMessage< ::pg_query::PartitionElem >(GetArenaForAllocation()); } return _impl_.node_.partition_elem_; } inline ::pg_query::PartitionElem* Node::mutable_partition_elem() { ::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 = 221 [json_name = "PartitionSpec"]; inline bool Node::_internal_has_partition_spec() const { return node_case() == kPartitionSpec; } inline bool Node::has_partition_spec() const { return _internal_has_partition_spec(); } inline void Node::set_has_partition_spec() { _impl_._oneof_case_[0] = kPartitionSpec; } inline void Node::clear_partition_spec() { if (_internal_has_partition_spec()) { if (GetArenaForAllocation() == 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 (_internal_has_partition_spec()) { clear_has_node(); ::pg_query::PartitionSpec* temp = _impl_.node_.partition_spec_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.partition_spec_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::PartitionSpec& Node::_internal_partition_spec() const { return _internal_has_partition_spec() ? *_impl_.node_.partition_spec_ : reinterpret_cast< ::pg_query::PartitionSpec&>(::pg_query::_PartitionSpec_default_instance_); } inline const ::pg_query::PartitionSpec& Node::partition_spec() const { // @@protoc_insertion_point(field_get:pg_query.Node.partition_spec) return _internal_partition_spec(); } inline ::pg_query::PartitionSpec* Node::unsafe_arena_release_partition_spec() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.partition_spec) if (_internal_has_partition_spec()) { clear_has_node(); ::pg_query::PartitionSpec* temp = _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* partition_spec) { clear_node(); if (partition_spec) { set_has_partition_spec(); _impl_.node_.partition_spec_ = partition_spec; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.partition_spec) } inline ::pg_query::PartitionSpec* Node::_internal_mutable_partition_spec() { if (!_internal_has_partition_spec()) { clear_node(); set_has_partition_spec(); _impl_.node_.partition_spec_ = CreateMaybeMessage< ::pg_query::PartitionSpec >(GetArenaForAllocation()); } return _impl_.node_.partition_spec_; } inline ::pg_query::PartitionSpec* Node::mutable_partition_spec() { ::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 = 222 [json_name = "PartitionBoundSpec"]; inline bool Node::_internal_has_partition_bound_spec() const { return node_case() == kPartitionBoundSpec; } inline bool Node::has_partition_bound_spec() const { return _internal_has_partition_bound_spec(); } inline void Node::set_has_partition_bound_spec() { _impl_._oneof_case_[0] = kPartitionBoundSpec; } inline void Node::clear_partition_bound_spec() { if (_internal_has_partition_bound_spec()) { if (GetArenaForAllocation() == 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 (_internal_has_partition_bound_spec()) { clear_has_node(); ::pg_query::PartitionBoundSpec* temp = _impl_.node_.partition_bound_spec_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_partition_bound_spec() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.partition_bound_spec) return _internal_partition_bound_spec(); } inline ::pg_query::PartitionBoundSpec* Node::unsafe_arena_release_partition_bound_spec() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.partition_bound_spec) if (_internal_has_partition_bound_spec()) { clear_has_node(); ::pg_query::PartitionBoundSpec* temp = _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* partition_bound_spec) { clear_node(); if (partition_bound_spec) { set_has_partition_bound_spec(); _impl_.node_.partition_bound_spec_ = partition_bound_spec; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.partition_bound_spec) } inline ::pg_query::PartitionBoundSpec* Node::_internal_mutable_partition_bound_spec() { if (!_internal_has_partition_bound_spec()) { clear_node(); set_has_partition_bound_spec(); _impl_.node_.partition_bound_spec_ = CreateMaybeMessage< ::pg_query::PartitionBoundSpec >(GetArenaForAllocation()); } return _impl_.node_.partition_bound_spec_; } inline ::pg_query::PartitionBoundSpec* Node::mutable_partition_bound_spec() { ::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 = 223 [json_name = "PartitionRangeDatum"]; inline bool Node::_internal_has_partition_range_datum() const { return node_case() == kPartitionRangeDatum; } inline bool Node::has_partition_range_datum() const { return _internal_has_partition_range_datum(); } inline void Node::set_has_partition_range_datum() { _impl_._oneof_case_[0] = kPartitionRangeDatum; } inline void Node::clear_partition_range_datum() { if (_internal_has_partition_range_datum()) { if (GetArenaForAllocation() == 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 (_internal_has_partition_range_datum()) { clear_has_node(); ::pg_query::PartitionRangeDatum* temp = _impl_.node_.partition_range_datum_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_partition_range_datum() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.partition_range_datum) return _internal_partition_range_datum(); } inline ::pg_query::PartitionRangeDatum* Node::unsafe_arena_release_partition_range_datum() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.partition_range_datum) if (_internal_has_partition_range_datum()) { clear_has_node(); ::pg_query::PartitionRangeDatum* temp = _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* partition_range_datum) { clear_node(); if (partition_range_datum) { set_has_partition_range_datum(); _impl_.node_.partition_range_datum_ = partition_range_datum; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.partition_range_datum) } inline ::pg_query::PartitionRangeDatum* Node::_internal_mutable_partition_range_datum() { if (!_internal_has_partition_range_datum()) { clear_node(); set_has_partition_range_datum(); _impl_.node_.partition_range_datum_ = CreateMaybeMessage< ::pg_query::PartitionRangeDatum >(GetArenaForAllocation()); } return _impl_.node_.partition_range_datum_; } inline ::pg_query::PartitionRangeDatum* Node::mutable_partition_range_datum() { ::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 = 224 [json_name = "PartitionCmd"]; inline bool Node::_internal_has_partition_cmd() const { return node_case() == kPartitionCmd; } inline bool Node::has_partition_cmd() const { return _internal_has_partition_cmd(); } inline void Node::set_has_partition_cmd() { _impl_._oneof_case_[0] = kPartitionCmd; } inline void Node::clear_partition_cmd() { if (_internal_has_partition_cmd()) { if (GetArenaForAllocation() == 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 (_internal_has_partition_cmd()) { clear_has_node(); ::pg_query::PartitionCmd* temp = _impl_.node_.partition_cmd_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.partition_cmd_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::PartitionCmd& Node::_internal_partition_cmd() const { return _internal_has_partition_cmd() ? *_impl_.node_.partition_cmd_ : reinterpret_cast< ::pg_query::PartitionCmd&>(::pg_query::_PartitionCmd_default_instance_); } inline const ::pg_query::PartitionCmd& Node::partition_cmd() const { // @@protoc_insertion_point(field_get:pg_query.Node.partition_cmd) return _internal_partition_cmd(); } inline ::pg_query::PartitionCmd* Node::unsafe_arena_release_partition_cmd() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.partition_cmd) if (_internal_has_partition_cmd()) { clear_has_node(); ::pg_query::PartitionCmd* temp = _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* partition_cmd) { clear_node(); if (partition_cmd) { set_has_partition_cmd(); _impl_.node_.partition_cmd_ = partition_cmd; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.partition_cmd) } inline ::pg_query::PartitionCmd* Node::_internal_mutable_partition_cmd() { if (!_internal_has_partition_cmd()) { clear_node(); set_has_partition_cmd(); _impl_.node_.partition_cmd_ = CreateMaybeMessage< ::pg_query::PartitionCmd >(GetArenaForAllocation()); } return _impl_.node_.partition_cmd_; } inline ::pg_query::PartitionCmd* Node::mutable_partition_cmd() { ::pg_query::PartitionCmd* _msg = _internal_mutable_partition_cmd(); // @@protoc_insertion_point(field_mutable:pg_query.Node.partition_cmd) return _msg; } // .pg_query.VacuumRelation vacuum_relation = 225 [json_name = "VacuumRelation"]; inline bool Node::_internal_has_vacuum_relation() const { return node_case() == kVacuumRelation; } inline bool Node::has_vacuum_relation() const { return _internal_has_vacuum_relation(); } inline void Node::set_has_vacuum_relation() { _impl_._oneof_case_[0] = kVacuumRelation; } inline void Node::clear_vacuum_relation() { if (_internal_has_vacuum_relation()) { if (GetArenaForAllocation() == 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 (_internal_has_vacuum_relation()) { clear_has_node(); ::pg_query::VacuumRelation* temp = _impl_.node_.vacuum_relation_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.vacuum_relation_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::VacuumRelation& Node::_internal_vacuum_relation() const { return _internal_has_vacuum_relation() ? *_impl_.node_.vacuum_relation_ : reinterpret_cast< ::pg_query::VacuumRelation&>(::pg_query::_VacuumRelation_default_instance_); } inline const ::pg_query::VacuumRelation& Node::vacuum_relation() const { // @@protoc_insertion_point(field_get:pg_query.Node.vacuum_relation) return _internal_vacuum_relation(); } inline ::pg_query::VacuumRelation* Node::unsafe_arena_release_vacuum_relation() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.vacuum_relation) if (_internal_has_vacuum_relation()) { clear_has_node(); ::pg_query::VacuumRelation* temp = _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* vacuum_relation) { clear_node(); if (vacuum_relation) { set_has_vacuum_relation(); _impl_.node_.vacuum_relation_ = vacuum_relation; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.vacuum_relation) } inline ::pg_query::VacuumRelation* Node::_internal_mutable_vacuum_relation() { if (!_internal_has_vacuum_relation()) { clear_node(); set_has_vacuum_relation(); _impl_.node_.vacuum_relation_ = CreateMaybeMessage< ::pg_query::VacuumRelation >(GetArenaForAllocation()); } return _impl_.node_.vacuum_relation_; } inline ::pg_query::VacuumRelation* Node::mutable_vacuum_relation() { ::pg_query::VacuumRelation* _msg = _internal_mutable_vacuum_relation(); // @@protoc_insertion_point(field_mutable:pg_query.Node.vacuum_relation) return _msg; } // .pg_query.PublicationObjSpec publication_obj_spec = 226 [json_name = "PublicationObjSpec"]; inline bool Node::_internal_has_publication_obj_spec() const { return node_case() == kPublicationObjSpec; } inline bool Node::has_publication_obj_spec() const { return _internal_has_publication_obj_spec(); } inline void Node::set_has_publication_obj_spec() { _impl_._oneof_case_[0] = kPublicationObjSpec; } inline void Node::clear_publication_obj_spec() { if (_internal_has_publication_obj_spec()) { if (GetArenaForAllocation() == 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 (_internal_has_publication_obj_spec()) { clear_has_node(); ::pg_query::PublicationObjSpec* temp = _impl_.node_.publication_obj_spec_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_publication_obj_spec() ? *_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 { // @@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 (_internal_has_publication_obj_spec()) { clear_has_node(); ::pg_query::PublicationObjSpec* 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* publication_obj_spec) { clear_node(); if (publication_obj_spec) { set_has_publication_obj_spec(); _impl_.node_.publication_obj_spec_ = publication_obj_spec; } // @@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 (!_internal_has_publication_obj_spec()) { clear_node(); set_has_publication_obj_spec(); _impl_.node_.publication_obj_spec_ = CreateMaybeMessage< ::pg_query::PublicationObjSpec >(GetArenaForAllocation()); } return _impl_.node_.publication_obj_spec_; } inline ::pg_query::PublicationObjSpec* Node::mutable_publication_obj_spec() { ::pg_query::PublicationObjSpec* _msg = _internal_mutable_publication_obj_spec(); // @@protoc_insertion_point(field_mutable:pg_query.Node.publication_obj_spec) return _msg; } // .pg_query.PublicationTable publication_table = 227 [json_name = "PublicationTable"]; inline bool Node::_internal_has_publication_table() const { return node_case() == kPublicationTable; } inline bool Node::has_publication_table() const { return _internal_has_publication_table(); } inline void Node::set_has_publication_table() { _impl_._oneof_case_[0] = kPublicationTable; } inline void Node::clear_publication_table() { if (_internal_has_publication_table()) { if (GetArenaForAllocation() == 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 (_internal_has_publication_table()) { clear_has_node(); ::pg_query::PublicationTable* temp = _impl_.node_.publication_table_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.publication_table_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::PublicationTable& Node::_internal_publication_table() const { return _internal_has_publication_table() ? *_impl_.node_.publication_table_ : reinterpret_cast< ::pg_query::PublicationTable&>(::pg_query::_PublicationTable_default_instance_); } inline const ::pg_query::PublicationTable& Node::publication_table() const { // @@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 (_internal_has_publication_table()) { clear_has_node(); ::pg_query::PublicationTable* 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* publication_table) { clear_node(); if (publication_table) { set_has_publication_table(); _impl_.node_.publication_table_ = publication_table; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.publication_table) } inline ::pg_query::PublicationTable* Node::_internal_mutable_publication_table() { if (!_internal_has_publication_table()) { clear_node(); set_has_publication_table(); _impl_.node_.publication_table_ = CreateMaybeMessage< ::pg_query::PublicationTable >(GetArenaForAllocation()); } return _impl_.node_.publication_table_; } inline ::pg_query::PublicationTable* Node::mutable_publication_table() { ::pg_query::PublicationTable* _msg = _internal_mutable_publication_table(); // @@protoc_insertion_point(field_mutable:pg_query.Node.publication_table) return _msg; } // .pg_query.InlineCodeBlock inline_code_block = 228 [json_name = "InlineCodeBlock"]; inline bool Node::_internal_has_inline_code_block() const { return node_case() == kInlineCodeBlock; } inline bool Node::has_inline_code_block() const { return _internal_has_inline_code_block(); } inline void Node::set_has_inline_code_block() { _impl_._oneof_case_[0] = kInlineCodeBlock; } inline void Node::clear_inline_code_block() { if (_internal_has_inline_code_block()) { if (GetArenaForAllocation() == 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 (_internal_has_inline_code_block()) { clear_has_node(); ::pg_query::InlineCodeBlock* temp = _impl_.node_.inline_code_block_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_inline_code_block() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.inline_code_block) return _internal_inline_code_block(); } inline ::pg_query::InlineCodeBlock* Node::unsafe_arena_release_inline_code_block() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.inline_code_block) if (_internal_has_inline_code_block()) { clear_has_node(); ::pg_query::InlineCodeBlock* temp = _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* inline_code_block) { clear_node(); if (inline_code_block) { set_has_inline_code_block(); _impl_.node_.inline_code_block_ = inline_code_block; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.inline_code_block) } inline ::pg_query::InlineCodeBlock* Node::_internal_mutable_inline_code_block() { if (!_internal_has_inline_code_block()) { clear_node(); set_has_inline_code_block(); _impl_.node_.inline_code_block_ = CreateMaybeMessage< ::pg_query::InlineCodeBlock >(GetArenaForAllocation()); } return _impl_.node_.inline_code_block_; } inline ::pg_query::InlineCodeBlock* Node::mutable_inline_code_block() { ::pg_query::InlineCodeBlock* _msg = _internal_mutable_inline_code_block(); // @@protoc_insertion_point(field_mutable:pg_query.Node.inline_code_block) return _msg; } // .pg_query.CallContext call_context = 229 [json_name = "CallContext"]; inline bool Node::_internal_has_call_context() const { return node_case() == kCallContext; } inline bool Node::has_call_context() const { return _internal_has_call_context(); } inline void Node::set_has_call_context() { _impl_._oneof_case_[0] = kCallContext; } inline void Node::clear_call_context() { if (_internal_has_call_context()) { if (GetArenaForAllocation() == 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 (_internal_has_call_context()) { clear_has_node(); ::pg_query::CallContext* temp = _impl_.node_.call_context_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.call_context_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::CallContext& Node::_internal_call_context() const { return _internal_has_call_context() ? *_impl_.node_.call_context_ : reinterpret_cast< ::pg_query::CallContext&>(::pg_query::_CallContext_default_instance_); } inline const ::pg_query::CallContext& Node::call_context() const { // @@protoc_insertion_point(field_get:pg_query.Node.call_context) return _internal_call_context(); } inline ::pg_query::CallContext* Node::unsafe_arena_release_call_context() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.call_context) if (_internal_has_call_context()) { clear_has_node(); ::pg_query::CallContext* temp = _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* call_context) { clear_node(); if (call_context) { set_has_call_context(); _impl_.node_.call_context_ = call_context; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.call_context) } inline ::pg_query::CallContext* Node::_internal_mutable_call_context() { if (!_internal_has_call_context()) { clear_node(); set_has_call_context(); _impl_.node_.call_context_ = CreateMaybeMessage< ::pg_query::CallContext >(GetArenaForAllocation()); } return _impl_.node_.call_context_; } inline ::pg_query::CallContext* Node::mutable_call_context() { ::pg_query::CallContext* _msg = _internal_mutable_call_context(); // @@protoc_insertion_point(field_mutable:pg_query.Node.call_context) return _msg; } // .pg_query.Integer integer = 230 [json_name = "Integer"]; inline bool Node::_internal_has_integer() const { return node_case() == kInteger; } inline bool Node::has_integer() const { return _internal_has_integer(); } inline void Node::set_has_integer() { _impl_._oneof_case_[0] = kInteger; } inline void Node::clear_integer() { if (_internal_has_integer()) { if (GetArenaForAllocation() == 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 (_internal_has_integer()) { clear_has_node(); ::pg_query::Integer* temp = _impl_.node_.integer_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.integer_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::Integer& Node::_internal_integer() const { return _internal_has_integer() ? *_impl_.node_.integer_ : reinterpret_cast< ::pg_query::Integer&>(::pg_query::_Integer_default_instance_); } inline const ::pg_query::Integer& Node::integer() const { // @@protoc_insertion_point(field_get:pg_query.Node.integer) return _internal_integer(); } inline ::pg_query::Integer* Node::unsafe_arena_release_integer() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.integer) if (_internal_has_integer()) { clear_has_node(); ::pg_query::Integer* temp = _impl_.node_.integer_; _impl_.node_.integer_ = nullptr; return temp; } else { return nullptr; } } inline void Node::unsafe_arena_set_allocated_integer(::pg_query::Integer* integer) { clear_node(); if (integer) { set_has_integer(); _impl_.node_.integer_ = integer; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.integer) } inline ::pg_query::Integer* Node::_internal_mutable_integer() { if (!_internal_has_integer()) { clear_node(); set_has_integer(); _impl_.node_.integer_ = CreateMaybeMessage< ::pg_query::Integer >(GetArenaForAllocation()); } return _impl_.node_.integer_; } inline ::pg_query::Integer* Node::mutable_integer() { ::pg_query::Integer* _msg = _internal_mutable_integer(); // @@protoc_insertion_point(field_mutable:pg_query.Node.integer) return _msg; } // .pg_query.Float float = 231 [json_name = "Float"]; inline bool Node::_internal_has_float_() const { return node_case() == kFloat; } inline bool Node::has_float_() const { return _internal_has_float_(); } inline void Node::set_has_float_() { _impl_._oneof_case_[0] = kFloat; } inline void Node::clear_float_() { if (_internal_has_float_()) { if (GetArenaForAllocation() == 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 (_internal_has_float_()) { clear_has_node(); ::pg_query::Float* temp = _impl_.node_.float__; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.float__ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::Float& Node::_internal_float_() const { return _internal_has_float_() ? *_impl_.node_.float__ : reinterpret_cast< ::pg_query::Float&>(::pg_query::_Float_default_instance_); } inline const ::pg_query::Float& Node::float_() const { // @@protoc_insertion_point(field_get:pg_query.Node.float) return _internal_float_(); } inline ::pg_query::Float* Node::unsafe_arena_release_float_() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.float) if (_internal_has_float_()) { clear_has_node(); ::pg_query::Float* temp = _impl_.node_.float__; _impl_.node_.float__ = nullptr; return temp; } else { return nullptr; } } inline void Node::unsafe_arena_set_allocated_float_(::pg_query::Float* float_) { clear_node(); if (float_) { set_has_float_(); _impl_.node_.float__ = float_; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.float) } inline ::pg_query::Float* Node::_internal_mutable_float_() { if (!_internal_has_float_()) { clear_node(); set_has_float_(); _impl_.node_.float__ = CreateMaybeMessage< ::pg_query::Float >(GetArenaForAllocation()); } return _impl_.node_.float__; } inline ::pg_query::Float* Node::mutable_float_() { ::pg_query::Float* _msg = _internal_mutable_float_(); // @@protoc_insertion_point(field_mutable:pg_query.Node.float) return _msg; } // .pg_query.Boolean boolean = 232 [json_name = "Boolean"]; inline bool Node::_internal_has_boolean() const { return node_case() == kBoolean; } inline bool Node::has_boolean() const { return _internal_has_boolean(); } inline void Node::set_has_boolean() { _impl_._oneof_case_[0] = kBoolean; } inline void Node::clear_boolean() { if (_internal_has_boolean()) { if (GetArenaForAllocation() == 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 (_internal_has_boolean()) { clear_has_node(); ::pg_query::Boolean* temp = _impl_.node_.boolean_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.boolean_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::Boolean& Node::_internal_boolean() const { return _internal_has_boolean() ? *_impl_.node_.boolean_ : reinterpret_cast< ::pg_query::Boolean&>(::pg_query::_Boolean_default_instance_); } inline const ::pg_query::Boolean& Node::boolean() const { // @@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 (_internal_has_boolean()) { clear_has_node(); ::pg_query::Boolean* temp = _impl_.node_.boolean_; _impl_.node_.boolean_ = nullptr; return temp; } else { return nullptr; } } inline void Node::unsafe_arena_set_allocated_boolean(::pg_query::Boolean* boolean) { clear_node(); if (boolean) { set_has_boolean(); _impl_.node_.boolean_ = boolean; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.boolean) } inline ::pg_query::Boolean* Node::_internal_mutable_boolean() { if (!_internal_has_boolean()) { clear_node(); set_has_boolean(); _impl_.node_.boolean_ = CreateMaybeMessage< ::pg_query::Boolean >(GetArenaForAllocation()); } return _impl_.node_.boolean_; } inline ::pg_query::Boolean* Node::mutable_boolean() { ::pg_query::Boolean* _msg = _internal_mutable_boolean(); // @@protoc_insertion_point(field_mutable:pg_query.Node.boolean) return _msg; } // .pg_query.String string = 233 [json_name = "String"]; inline bool Node::_internal_has_string() const { return node_case() == kString; } inline bool Node::has_string() const { return _internal_has_string(); } inline void Node::set_has_string() { _impl_._oneof_case_[0] = kString; } inline void Node::clear_string() { if (_internal_has_string()) { if (GetArenaForAllocation() == 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 (_internal_has_string()) { clear_has_node(); ::pg_query::String* temp = _impl_.node_.string_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.string_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::String& Node::_internal_string() const { return _internal_has_string() ? *_impl_.node_.string_ : reinterpret_cast< ::pg_query::String&>(::pg_query::_String_default_instance_); } inline const ::pg_query::String& Node::string() const { // @@protoc_insertion_point(field_get:pg_query.Node.string) return _internal_string(); } inline ::pg_query::String* Node::unsafe_arena_release_string() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.string) if (_internal_has_string()) { clear_has_node(); ::pg_query::String* temp = _impl_.node_.string_; _impl_.node_.string_ = nullptr; return temp; } else { return nullptr; } } inline void Node::unsafe_arena_set_allocated_string(::pg_query::String* string) { clear_node(); if (string) { set_has_string(); _impl_.node_.string_ = string; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.string) } inline ::pg_query::String* Node::_internal_mutable_string() { if (!_internal_has_string()) { clear_node(); set_has_string(); _impl_.node_.string_ = CreateMaybeMessage< ::pg_query::String >(GetArenaForAllocation()); } return _impl_.node_.string_; } inline ::pg_query::String* Node::mutable_string() { ::pg_query::String* _msg = _internal_mutable_string(); // @@protoc_insertion_point(field_mutable:pg_query.Node.string) return _msg; } // .pg_query.BitString bit_string = 234 [json_name = "BitString"]; inline bool Node::_internal_has_bit_string() const { return node_case() == kBitString; } inline bool Node::has_bit_string() const { return _internal_has_bit_string(); } inline void Node::set_has_bit_string() { _impl_._oneof_case_[0] = kBitString; } inline void Node::clear_bit_string() { if (_internal_has_bit_string()) { if (GetArenaForAllocation() == 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 (_internal_has_bit_string()) { clear_has_node(); ::pg_query::BitString* temp = _impl_.node_.bit_string_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.bit_string_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::BitString& Node::_internal_bit_string() const { return _internal_has_bit_string() ? *_impl_.node_.bit_string_ : reinterpret_cast< ::pg_query::BitString&>(::pg_query::_BitString_default_instance_); } inline const ::pg_query::BitString& Node::bit_string() const { // @@protoc_insertion_point(field_get:pg_query.Node.bit_string) return _internal_bit_string(); } inline ::pg_query::BitString* Node::unsafe_arena_release_bit_string() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.bit_string) if (_internal_has_bit_string()) { clear_has_node(); ::pg_query::BitString* temp = _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* bit_string) { clear_node(); if (bit_string) { set_has_bit_string(); _impl_.node_.bit_string_ = bit_string; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.bit_string) } inline ::pg_query::BitString* Node::_internal_mutable_bit_string() { if (!_internal_has_bit_string()) { clear_node(); set_has_bit_string(); _impl_.node_.bit_string_ = CreateMaybeMessage< ::pg_query::BitString >(GetArenaForAllocation()); } return _impl_.node_.bit_string_; } inline ::pg_query::BitString* Node::mutable_bit_string() { ::pg_query::BitString* _msg = _internal_mutable_bit_string(); // @@protoc_insertion_point(field_mutable:pg_query.Node.bit_string) return _msg; } // .pg_query.List list = 235 [json_name = "List"]; inline bool Node::_internal_has_list() const { return node_case() == kList; } inline bool Node::has_list() const { return _internal_has_list(); } inline void Node::set_has_list() { _impl_._oneof_case_[0] = kList; } inline void Node::clear_list() { if (_internal_has_list()) { if (GetArenaForAllocation() == 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 (_internal_has_list()) { clear_has_node(); ::pg_query::List* temp = _impl_.node_.list_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.list_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::List& Node::_internal_list() const { return _internal_has_list() ? *_impl_.node_.list_ : reinterpret_cast< ::pg_query::List&>(::pg_query::_List_default_instance_); } inline const ::pg_query::List& Node::list() const { // @@protoc_insertion_point(field_get:pg_query.Node.list) return _internal_list(); } inline ::pg_query::List* Node::unsafe_arena_release_list() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.list) if (_internal_has_list()) { clear_has_node(); ::pg_query::List* temp = _impl_.node_.list_; _impl_.node_.list_ = nullptr; return temp; } else { return nullptr; } } inline void Node::unsafe_arena_set_allocated_list(::pg_query::List* list) { clear_node(); if (list) { set_has_list(); _impl_.node_.list_ = list; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.list) } inline ::pg_query::List* Node::_internal_mutable_list() { if (!_internal_has_list()) { clear_node(); set_has_list(); _impl_.node_.list_ = CreateMaybeMessage< ::pg_query::List >(GetArenaForAllocation()); } return _impl_.node_.list_; } inline ::pg_query::List* Node::mutable_list() { ::pg_query::List* _msg = _internal_mutable_list(); // @@protoc_insertion_point(field_mutable:pg_query.Node.list) return _msg; } // .pg_query.IntList int_list = 236 [json_name = "IntList"]; inline bool Node::_internal_has_int_list() const { return node_case() == kIntList; } inline bool Node::has_int_list() const { return _internal_has_int_list(); } inline void Node::set_has_int_list() { _impl_._oneof_case_[0] = kIntList; } inline void Node::clear_int_list() { if (_internal_has_int_list()) { if (GetArenaForAllocation() == 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 (_internal_has_int_list()) { clear_has_node(); ::pg_query::IntList* temp = _impl_.node_.int_list_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.int_list_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::IntList& Node::_internal_int_list() const { return _internal_has_int_list() ? *_impl_.node_.int_list_ : reinterpret_cast< ::pg_query::IntList&>(::pg_query::_IntList_default_instance_); } inline const ::pg_query::IntList& Node::int_list() const { // @@protoc_insertion_point(field_get:pg_query.Node.int_list) return _internal_int_list(); } inline ::pg_query::IntList* Node::unsafe_arena_release_int_list() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.int_list) if (_internal_has_int_list()) { clear_has_node(); ::pg_query::IntList* temp = _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* int_list) { clear_node(); if (int_list) { set_has_int_list(); _impl_.node_.int_list_ = int_list; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.int_list) } inline ::pg_query::IntList* Node::_internal_mutable_int_list() { if (!_internal_has_int_list()) { clear_node(); set_has_int_list(); _impl_.node_.int_list_ = CreateMaybeMessage< ::pg_query::IntList >(GetArenaForAllocation()); } return _impl_.node_.int_list_; } inline ::pg_query::IntList* Node::mutable_int_list() { ::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 = 237 [json_name = "OidList"]; inline bool Node::_internal_has_oid_list() const { return node_case() == kOidList; } inline bool Node::has_oid_list() const { return _internal_has_oid_list(); } inline void Node::set_has_oid_list() { _impl_._oneof_case_[0] = kOidList; } inline void Node::clear_oid_list() { if (_internal_has_oid_list()) { if (GetArenaForAllocation() == 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 (_internal_has_oid_list()) { clear_has_node(); ::pg_query::OidList* temp = _impl_.node_.oid_list_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.node_.oid_list_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::OidList& Node::_internal_oid_list() const { return _internal_has_oid_list() ? *_impl_.node_.oid_list_ : reinterpret_cast< ::pg_query::OidList&>(::pg_query::_OidList_default_instance_); } inline const ::pg_query::OidList& Node::oid_list() const { // @@protoc_insertion_point(field_get:pg_query.Node.oid_list) return _internal_oid_list(); } inline ::pg_query::OidList* Node::unsafe_arena_release_oid_list() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.oid_list) if (_internal_has_oid_list()) { clear_has_node(); ::pg_query::OidList* temp = _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* oid_list) { clear_node(); if (oid_list) { set_has_oid_list(); _impl_.node_.oid_list_ = oid_list; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.oid_list) } inline ::pg_query::OidList* Node::_internal_mutable_oid_list() { if (!_internal_has_oid_list()) { clear_node(); set_has_oid_list(); _impl_.node_.oid_list_ = CreateMaybeMessage< ::pg_query::OidList >(GetArenaForAllocation()); } return _impl_.node_.oid_list_; } inline ::pg_query::OidList* Node::mutable_oid_list() { ::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 = 238 [json_name = "A_Const"]; inline bool Node::_internal_has_a_const() const { return node_case() == kAConst; } inline bool Node::has_a_const() const { return _internal_has_a_const(); } inline void Node::set_has_a_const() { _impl_._oneof_case_[0] = kAConst; } inline void Node::clear_a_const() { if (_internal_has_a_const()) { if (GetArenaForAllocation() == 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 (_internal_has_a_const()) { clear_has_node(); ::pg_query::A_Const* temp = _impl_.node_.a_const_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::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 _internal_has_a_const() ? *_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 { // @@protoc_insertion_point(field_get:pg_query.Node.a_const) return _internal_a_const(); } inline ::pg_query::A_Const* Node::unsafe_arena_release_a_const() { // @@protoc_insertion_point(field_unsafe_arena_release:pg_query.Node.a_const) if (_internal_has_a_const()) { clear_has_node(); ::pg_query::A_Const* temp = _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* a_const) { clear_node(); if (a_const) { set_has_a_const(); _impl_.node_.a_const_ = a_const; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Node.a_const) } inline ::pg_query::A_Const* Node::_internal_mutable_a_const() { if (!_internal_has_a_const()) { clear_node(); set_has_a_const(); _impl_.node_.a_const_ = CreateMaybeMessage< ::pg_query::A_Const >(GetArenaForAllocation()); } return _impl_.node_.a_const_; } inline ::pg_query::A_Const* Node::mutable_a_const() { ::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() { _impl_.ival_ = 0; } inline int32_t Integer::_internal_ival() const { return _impl_.ival_; } inline int32_t Integer::ival() const { // @@protoc_insertion_point(field_get:pg_query.Integer.ival) return _internal_ival(); } inline void Integer::_internal_set_ival(int32_t value) { _impl_.ival_ = value; } inline void Integer::set_ival(int32_t value) { _internal_set_ival(value); // @@protoc_insertion_point(field_set:pg_query.Integer.ival) } // ------------------------------------------------------------------- // Float // string fval = 1; inline void Float::clear_fval() { _impl_.fval_.ClearToEmpty(); } inline const std::string& Float::fval() const { // @@protoc_insertion_point(field_get:pg_query.Float.fval) return _internal_fval(); } template inline PROTOBUF_ALWAYS_INLINE void Float::set_fval(ArgT0&& arg0, ArgT... args) { _impl_.fval_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.Float.fval) } inline std::string* Float::mutable_fval() { 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 { return _impl_.fval_.Get(); } inline void Float::_internal_set_fval(const std::string& value) { _impl_.fval_.Set(value, GetArenaForAllocation()); } inline std::string* Float::_internal_mutable_fval() { return _impl_.fval_.Mutable(GetArenaForAllocation()); } inline std::string* Float::release_fval() { // @@protoc_insertion_point(field_release:pg_query.Float.fval) return _impl_.fval_.Release(); } inline void Float::set_allocated_fval(std::string* fval) { if (fval != nullptr) { } else { } _impl_.fval_.SetAllocated(fval, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.fval_.IsDefault()) { _impl_.fval_.Set("", GetArenaForAllocation()); } #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() { _impl_.boolval_ = false; } inline bool Boolean::_internal_boolval() const { return _impl_.boolval_; } inline bool Boolean::boolval() const { // @@protoc_insertion_point(field_get:pg_query.Boolean.boolval) return _internal_boolval(); } inline void Boolean::_internal_set_boolval(bool value) { _impl_.boolval_ = value; } inline void Boolean::set_boolval(bool value) { _internal_set_boolval(value); // @@protoc_insertion_point(field_set:pg_query.Boolean.boolval) } // ------------------------------------------------------------------- // String // string sval = 1; inline void String::clear_sval() { _impl_.sval_.ClearToEmpty(); } inline const std::string& String::sval() const { // @@protoc_insertion_point(field_get:pg_query.String.sval) return _internal_sval(); } template inline PROTOBUF_ALWAYS_INLINE void String::set_sval(ArgT0&& arg0, ArgT... args) { _impl_.sval_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.String.sval) } inline std::string* String::mutable_sval() { 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 { return _impl_.sval_.Get(); } inline void String::_internal_set_sval(const std::string& value) { _impl_.sval_.Set(value, GetArenaForAllocation()); } inline std::string* String::_internal_mutable_sval() { return _impl_.sval_.Mutable(GetArenaForAllocation()); } inline std::string* String::release_sval() { // @@protoc_insertion_point(field_release:pg_query.String.sval) return _impl_.sval_.Release(); } inline void String::set_allocated_sval(std::string* sval) { if (sval != nullptr) { } else { } _impl_.sval_.SetAllocated(sval, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.sval_.IsDefault()) { _impl_.sval_.Set("", GetArenaForAllocation()); } #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() { _impl_.bsval_.ClearToEmpty(); } inline const std::string& BitString::bsval() const { // @@protoc_insertion_point(field_get:pg_query.BitString.bsval) return _internal_bsval(); } template inline PROTOBUF_ALWAYS_INLINE void BitString::set_bsval(ArgT0&& arg0, ArgT... args) { _impl_.bsval_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.BitString.bsval) } inline std::string* BitString::mutable_bsval() { 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 { return _impl_.bsval_.Get(); } inline void BitString::_internal_set_bsval(const std::string& value) { _impl_.bsval_.Set(value, GetArenaForAllocation()); } inline std::string* BitString::_internal_mutable_bsval() { return _impl_.bsval_.Mutable(GetArenaForAllocation()); } inline std::string* BitString::release_bsval() { // @@protoc_insertion_point(field_release:pg_query.BitString.bsval) return _impl_.bsval_.Release(); } inline void BitString::set_allocated_bsval(std::string* bsval) { if (bsval != nullptr) { } else { } _impl_.bsval_.SetAllocated(bsval, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.bsval_.IsDefault()) { _impl_.bsval_.Set("", GetArenaForAllocation()); } #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 _impl_.items_.size(); } inline int List::items_size() const { return _internal_items_size(); } inline void List::clear_items() { _impl_.items_.Clear(); } inline ::pg_query::Node* List::mutable_items(int index) { // @@protoc_insertion_point(field_mutable:pg_query.List.items) return _impl_.items_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* List::mutable_items() { // @@protoc_insertion_point(field_mutable_list:pg_query.List.items) return &_impl_.items_; } inline const ::pg_query::Node& List::_internal_items(int index) const { return _impl_.items_.Get(index); } inline const ::pg_query::Node& List::items(int index) const { // @@protoc_insertion_point(field_get:pg_query.List.items) return _internal_items(index); } inline ::pg_query::Node* List::_internal_add_items() { return _impl_.items_.Add(); } inline ::pg_query::Node* List::add_items() { ::pg_query::Node* _add = _internal_add_items(); // @@protoc_insertion_point(field_add:pg_query.List.items) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& List::items() const { // @@protoc_insertion_point(field_list:pg_query.List.items) return _impl_.items_; } // ------------------------------------------------------------------- // OidList // repeated .pg_query.Node items = 1; inline int OidList::_internal_items_size() const { return _impl_.items_.size(); } inline int OidList::items_size() const { return _internal_items_size(); } inline void OidList::clear_items() { _impl_.items_.Clear(); } inline ::pg_query::Node* OidList::mutable_items(int index) { // @@protoc_insertion_point(field_mutable:pg_query.OidList.items) return _impl_.items_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* OidList::mutable_items() { // @@protoc_insertion_point(field_mutable_list:pg_query.OidList.items) return &_impl_.items_; } inline const ::pg_query::Node& OidList::_internal_items(int index) const { return _impl_.items_.Get(index); } inline const ::pg_query::Node& OidList::items(int index) const { // @@protoc_insertion_point(field_get:pg_query.OidList.items) return _internal_items(index); } inline ::pg_query::Node* OidList::_internal_add_items() { return _impl_.items_.Add(); } inline ::pg_query::Node* OidList::add_items() { ::pg_query::Node* _add = _internal_add_items(); // @@protoc_insertion_point(field_add:pg_query.OidList.items) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& OidList::items() const { // @@protoc_insertion_point(field_list:pg_query.OidList.items) return _impl_.items_; } // ------------------------------------------------------------------- // IntList // repeated .pg_query.Node items = 1; inline int IntList::_internal_items_size() const { return _impl_.items_.size(); } inline int IntList::items_size() const { return _internal_items_size(); } inline void IntList::clear_items() { _impl_.items_.Clear(); } inline ::pg_query::Node* IntList::mutable_items(int index) { // @@protoc_insertion_point(field_mutable:pg_query.IntList.items) return _impl_.items_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* IntList::mutable_items() { // @@protoc_insertion_point(field_mutable_list:pg_query.IntList.items) return &_impl_.items_; } inline const ::pg_query::Node& IntList::_internal_items(int index) const { return _impl_.items_.Get(index); } inline const ::pg_query::Node& IntList::items(int index) const { // @@protoc_insertion_point(field_get:pg_query.IntList.items) return _internal_items(index); } inline ::pg_query::Node* IntList::_internal_add_items() { return _impl_.items_.Add(); } inline ::pg_query::Node* IntList::add_items() { ::pg_query::Node* _add = _internal_add_items(); // @@protoc_insertion_point(field_add:pg_query.IntList.items) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& IntList::items() const { // @@protoc_insertion_point(field_list:pg_query.IntList.items) return _impl_.items_; } // ------------------------------------------------------------------- // A_Const // .pg_query.Integer ival = 1; inline bool A_Const::_internal_has_ival() const { return val_case() == kIval; } inline bool A_Const::has_ival() const { return _internal_has_ival(); } inline void A_Const::set_has_ival() { _impl_._oneof_case_[0] = kIval; } inline void A_Const::clear_ival() { if (_internal_has_ival()) { if (GetArenaForAllocation() == 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 (_internal_has_ival()) { clear_has_val(); ::pg_query::Integer* temp = _impl_.val_.ival_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.val_.ival_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::Integer& A_Const::_internal_ival() const { return _internal_has_ival() ? *_impl_.val_.ival_ : reinterpret_cast< ::pg_query::Integer&>(::pg_query::_Integer_default_instance_); } inline const ::pg_query::Integer& A_Const::ival() const { // @@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 (_internal_has_ival()) { clear_has_val(); ::pg_query::Integer* 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* ival) { clear_val(); if (ival) { set_has_ival(); _impl_.val_.ival_ = ival; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.A_Const.ival) } inline ::pg_query::Integer* A_Const::_internal_mutable_ival() { if (!_internal_has_ival()) { clear_val(); set_has_ival(); _impl_.val_.ival_ = CreateMaybeMessage< ::pg_query::Integer >(GetArenaForAllocation()); } return _impl_.val_.ival_; } inline ::pg_query::Integer* A_Const::mutable_ival() { ::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::_internal_has_fval() const { return val_case() == kFval; } inline bool A_Const::has_fval() const { return _internal_has_fval(); } inline void A_Const::set_has_fval() { _impl_._oneof_case_[0] = kFval; } inline void A_Const::clear_fval() { if (_internal_has_fval()) { if (GetArenaForAllocation() == 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 (_internal_has_fval()) { clear_has_val(); ::pg_query::Float* temp = _impl_.val_.fval_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.val_.fval_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::Float& A_Const::_internal_fval() const { return _internal_has_fval() ? *_impl_.val_.fval_ : reinterpret_cast< ::pg_query::Float&>(::pg_query::_Float_default_instance_); } inline const ::pg_query::Float& A_Const::fval() const { // @@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 (_internal_has_fval()) { clear_has_val(); ::pg_query::Float* 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* fval) { clear_val(); if (fval) { set_has_fval(); _impl_.val_.fval_ = fval; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.A_Const.fval) } inline ::pg_query::Float* A_Const::_internal_mutable_fval() { if (!_internal_has_fval()) { clear_val(); set_has_fval(); _impl_.val_.fval_ = CreateMaybeMessage< ::pg_query::Float >(GetArenaForAllocation()); } return _impl_.val_.fval_; } inline ::pg_query::Float* A_Const::mutable_fval() { ::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::_internal_has_boolval() const { return val_case() == kBoolval; } inline bool A_Const::has_boolval() const { return _internal_has_boolval(); } inline void A_Const::set_has_boolval() { _impl_._oneof_case_[0] = kBoolval; } inline void A_Const::clear_boolval() { if (_internal_has_boolval()) { if (GetArenaForAllocation() == 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 (_internal_has_boolval()) { clear_has_val(); ::pg_query::Boolean* temp = _impl_.val_.boolval_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.val_.boolval_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::Boolean& A_Const::_internal_boolval() const { return _internal_has_boolval() ? *_impl_.val_.boolval_ : reinterpret_cast< ::pg_query::Boolean&>(::pg_query::_Boolean_default_instance_); } inline const ::pg_query::Boolean& A_Const::boolval() const { // @@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 (_internal_has_boolval()) { clear_has_val(); ::pg_query::Boolean* 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* boolval) { clear_val(); if (boolval) { set_has_boolval(); _impl_.val_.boolval_ = boolval; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.A_Const.boolval) } inline ::pg_query::Boolean* A_Const::_internal_mutable_boolval() { if (!_internal_has_boolval()) { clear_val(); set_has_boolval(); _impl_.val_.boolval_ = CreateMaybeMessage< ::pg_query::Boolean >(GetArenaForAllocation()); } return _impl_.val_.boolval_; } inline ::pg_query::Boolean* A_Const::mutable_boolval() { ::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::_internal_has_sval() const { return val_case() == kSval; } inline bool A_Const::has_sval() const { return _internal_has_sval(); } inline void A_Const::set_has_sval() { _impl_._oneof_case_[0] = kSval; } inline void A_Const::clear_sval() { if (_internal_has_sval()) { if (GetArenaForAllocation() == 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 (_internal_has_sval()) { clear_has_val(); ::pg_query::String* temp = _impl_.val_.sval_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.val_.sval_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::String& A_Const::_internal_sval() const { return _internal_has_sval() ? *_impl_.val_.sval_ : reinterpret_cast< ::pg_query::String&>(::pg_query::_String_default_instance_); } inline const ::pg_query::String& A_Const::sval() const { // @@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 (_internal_has_sval()) { clear_has_val(); ::pg_query::String* 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* sval) { clear_val(); if (sval) { set_has_sval(); _impl_.val_.sval_ = sval; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.A_Const.sval) } inline ::pg_query::String* A_Const::_internal_mutable_sval() { if (!_internal_has_sval()) { clear_val(); set_has_sval(); _impl_.val_.sval_ = CreateMaybeMessage< ::pg_query::String >(GetArenaForAllocation()); } return _impl_.val_.sval_; } inline ::pg_query::String* A_Const::mutable_sval() { ::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::_internal_has_bsval() const { return val_case() == kBsval; } inline bool A_Const::has_bsval() const { return _internal_has_bsval(); } inline void A_Const::set_has_bsval() { _impl_._oneof_case_[0] = kBsval; } inline void A_Const::clear_bsval() { if (_internal_has_bsval()) { if (GetArenaForAllocation() == 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 (_internal_has_bsval()) { clear_has_val(); ::pg_query::BitString* temp = _impl_.val_.bsval_; if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } _impl_.val_.bsval_ = nullptr; return temp; } else { return nullptr; } } inline const ::pg_query::BitString& A_Const::_internal_bsval() const { return _internal_has_bsval() ? *_impl_.val_.bsval_ : reinterpret_cast< ::pg_query::BitString&>(::pg_query::_BitString_default_instance_); } inline const ::pg_query::BitString& A_Const::bsval() const { // @@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 (_internal_has_bsval()) { clear_has_val(); ::pg_query::BitString* 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* bsval) { clear_val(); if (bsval) { set_has_bsval(); _impl_.val_.bsval_ = bsval; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.A_Const.bsval) } inline ::pg_query::BitString* A_Const::_internal_mutable_bsval() { if (!_internal_has_bsval()) { clear_val(); set_has_bsval(); _impl_.val_.bsval_ = CreateMaybeMessage< ::pg_query::BitString >(GetArenaForAllocation()); } return _impl_.val_.bsval_; } inline ::pg_query::BitString* A_Const::mutable_bsval() { ::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() { _impl_.isnull_ = false; } inline bool A_Const::_internal_isnull() const { return _impl_.isnull_; } inline bool A_Const::isnull() const { // @@protoc_insertion_point(field_get:pg_query.A_Const.isnull) return _internal_isnull(); } inline void A_Const::_internal_set_isnull(bool value) { _impl_.isnull_ = value; } inline void A_Const::set_isnull(bool value) { _internal_set_isnull(value); // @@protoc_insertion_point(field_set:pg_query.A_Const.isnull) } // int32 location = 11; inline void A_Const::clear_location() { _impl_.location_ = 0; } inline int32_t A_Const::_internal_location() const { return _impl_.location_; } inline int32_t A_Const::location() const { // @@protoc_insertion_point(field_get:pg_query.A_Const.location) return _internal_location(); } inline void A_Const::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void A_Const::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.A_Const.location) } 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() { _impl_.aliasname_.ClearToEmpty(); } inline const std::string& Alias::aliasname() const { // @@protoc_insertion_point(field_get:pg_query.Alias.aliasname) return _internal_aliasname(); } template inline PROTOBUF_ALWAYS_INLINE void Alias::set_aliasname(ArgT0&& arg0, ArgT... args) { _impl_.aliasname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.Alias.aliasname) } inline std::string* Alias::mutable_aliasname() { 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 { return _impl_.aliasname_.Get(); } inline void Alias::_internal_set_aliasname(const std::string& value) { _impl_.aliasname_.Set(value, GetArenaForAllocation()); } inline std::string* Alias::_internal_mutable_aliasname() { return _impl_.aliasname_.Mutable(GetArenaForAllocation()); } inline std::string* Alias::release_aliasname() { // @@protoc_insertion_point(field_release:pg_query.Alias.aliasname) return _impl_.aliasname_.Release(); } inline void Alias::set_allocated_aliasname(std::string* aliasname) { if (aliasname != nullptr) { } else { } _impl_.aliasname_.SetAllocated(aliasname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.aliasname_.IsDefault()) { _impl_.aliasname_.Set("", GetArenaForAllocation()); } #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 _impl_.colnames_.size(); } inline int Alias::colnames_size() const { return _internal_colnames_size(); } inline void Alias::clear_colnames() { _impl_.colnames_.Clear(); } inline ::pg_query::Node* Alias::mutable_colnames(int index) { // @@protoc_insertion_point(field_mutable:pg_query.Alias.colnames) return _impl_.colnames_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* Alias::mutable_colnames() { // @@protoc_insertion_point(field_mutable_list:pg_query.Alias.colnames) return &_impl_.colnames_; } inline const ::pg_query::Node& Alias::_internal_colnames(int index) const { return _impl_.colnames_.Get(index); } inline const ::pg_query::Node& Alias::colnames(int index) const { // @@protoc_insertion_point(field_get:pg_query.Alias.colnames) return _internal_colnames(index); } inline ::pg_query::Node* Alias::_internal_add_colnames() { return _impl_.colnames_.Add(); } inline ::pg_query::Node* Alias::add_colnames() { ::pg_query::Node* _add = _internal_add_colnames(); // @@protoc_insertion_point(field_add:pg_query.Alias.colnames) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& Alias::colnames() const { // @@protoc_insertion_point(field_list:pg_query.Alias.colnames) return _impl_.colnames_; } // ------------------------------------------------------------------- // RangeVar // string catalogname = 1 [json_name = "catalogname"]; inline void RangeVar::clear_catalogname() { _impl_.catalogname_.ClearToEmpty(); } inline const std::string& RangeVar::catalogname() const { // @@protoc_insertion_point(field_get:pg_query.RangeVar.catalogname) return _internal_catalogname(); } template inline PROTOBUF_ALWAYS_INLINE void RangeVar::set_catalogname(ArgT0&& arg0, ArgT... args) { _impl_.catalogname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.RangeVar.catalogname) } inline std::string* RangeVar::mutable_catalogname() { 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 { return _impl_.catalogname_.Get(); } inline void RangeVar::_internal_set_catalogname(const std::string& value) { _impl_.catalogname_.Set(value, GetArenaForAllocation()); } inline std::string* RangeVar::_internal_mutable_catalogname() { return _impl_.catalogname_.Mutable(GetArenaForAllocation()); } inline std::string* RangeVar::release_catalogname() { // @@protoc_insertion_point(field_release:pg_query.RangeVar.catalogname) return _impl_.catalogname_.Release(); } inline void RangeVar::set_allocated_catalogname(std::string* catalogname) { if (catalogname != nullptr) { } else { } _impl_.catalogname_.SetAllocated(catalogname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.catalogname_.IsDefault()) { _impl_.catalogname_.Set("", GetArenaForAllocation()); } #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() { _impl_.schemaname_.ClearToEmpty(); } inline const std::string& RangeVar::schemaname() const { // @@protoc_insertion_point(field_get:pg_query.RangeVar.schemaname) return _internal_schemaname(); } template inline PROTOBUF_ALWAYS_INLINE void RangeVar::set_schemaname(ArgT0&& arg0, ArgT... args) { _impl_.schemaname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.RangeVar.schemaname) } inline std::string* RangeVar::mutable_schemaname() { 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 { return _impl_.schemaname_.Get(); } inline void RangeVar::_internal_set_schemaname(const std::string& value) { _impl_.schemaname_.Set(value, GetArenaForAllocation()); } inline std::string* RangeVar::_internal_mutable_schemaname() { return _impl_.schemaname_.Mutable(GetArenaForAllocation()); } inline std::string* RangeVar::release_schemaname() { // @@protoc_insertion_point(field_release:pg_query.RangeVar.schemaname) return _impl_.schemaname_.Release(); } inline void RangeVar::set_allocated_schemaname(std::string* schemaname) { if (schemaname != nullptr) { } else { } _impl_.schemaname_.SetAllocated(schemaname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.schemaname_.IsDefault()) { _impl_.schemaname_.Set("", GetArenaForAllocation()); } #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() { _impl_.relname_.ClearToEmpty(); } inline const std::string& RangeVar::relname() const { // @@protoc_insertion_point(field_get:pg_query.RangeVar.relname) return _internal_relname(); } template inline PROTOBUF_ALWAYS_INLINE void RangeVar::set_relname(ArgT0&& arg0, ArgT... args) { _impl_.relname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.RangeVar.relname) } inline std::string* RangeVar::mutable_relname() { 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 { return _impl_.relname_.Get(); } inline void RangeVar::_internal_set_relname(const std::string& value) { _impl_.relname_.Set(value, GetArenaForAllocation()); } inline std::string* RangeVar::_internal_mutable_relname() { return _impl_.relname_.Mutable(GetArenaForAllocation()); } inline std::string* RangeVar::release_relname() { // @@protoc_insertion_point(field_release:pg_query.RangeVar.relname) return _impl_.relname_.Release(); } inline void RangeVar::set_allocated_relname(std::string* relname) { if (relname != nullptr) { } else { } _impl_.relname_.SetAllocated(relname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.relname_.IsDefault()) { _impl_.relname_.Set("", GetArenaForAllocation()); } #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() { _impl_.inh_ = false; } inline bool RangeVar::_internal_inh() const { return _impl_.inh_; } inline bool RangeVar::inh() const { // @@protoc_insertion_point(field_get:pg_query.RangeVar.inh) return _internal_inh(); } inline void RangeVar::_internal_set_inh(bool value) { _impl_.inh_ = value; } inline void RangeVar::set_inh(bool value) { _internal_set_inh(value); // @@protoc_insertion_point(field_set:pg_query.RangeVar.inh) } // string relpersistence = 5 [json_name = "relpersistence"]; inline void RangeVar::clear_relpersistence() { _impl_.relpersistence_.ClearToEmpty(); } inline const std::string& RangeVar::relpersistence() const { // @@protoc_insertion_point(field_get:pg_query.RangeVar.relpersistence) return _internal_relpersistence(); } template inline PROTOBUF_ALWAYS_INLINE void RangeVar::set_relpersistence(ArgT0&& arg0, ArgT... args) { _impl_.relpersistence_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.RangeVar.relpersistence) } inline std::string* RangeVar::mutable_relpersistence() { 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 { return _impl_.relpersistence_.Get(); } inline void RangeVar::_internal_set_relpersistence(const std::string& value) { _impl_.relpersistence_.Set(value, GetArenaForAllocation()); } inline std::string* RangeVar::_internal_mutable_relpersistence() { return _impl_.relpersistence_.Mutable(GetArenaForAllocation()); } inline std::string* RangeVar::release_relpersistence() { // @@protoc_insertion_point(field_release:pg_query.RangeVar.relpersistence) return _impl_.relpersistence_.Release(); } inline void RangeVar::set_allocated_relpersistence(std::string* relpersistence) { if (relpersistence != nullptr) { } else { } _impl_.relpersistence_.SetAllocated(relpersistence, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.relpersistence_.IsDefault()) { _impl_.relpersistence_.Set("", GetArenaForAllocation()); } #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::_internal_has_alias() const { return this != internal_default_instance() && _impl_.alias_ != nullptr; } inline bool RangeVar::has_alias() const { return _internal_has_alias(); } inline void RangeVar::clear_alias() { if (GetArenaForAllocation() == nullptr && _impl_.alias_ != nullptr) { delete _impl_.alias_; } _impl_.alias_ = nullptr; } inline const ::pg_query::Alias& RangeVar::_internal_alias() const { const ::pg_query::Alias* p = _impl_.alias_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Alias_default_instance_); } inline const ::pg_query::Alias& RangeVar::alias() const { // @@protoc_insertion_point(field_get:pg_query.RangeVar.alias) return _internal_alias(); } inline void RangeVar::unsafe_arena_set_allocated_alias( ::pg_query::Alias* alias) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.alias_); } _impl_.alias_ = alias; if (alias) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeVar.alias) } inline ::pg_query::Alias* RangeVar::release_alias() { ::pg_query::Alias* temp = _impl_.alias_; _impl_.alias_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Alias* RangeVar::unsafe_arena_release_alias() { // @@protoc_insertion_point(field_release:pg_query.RangeVar.alias) ::pg_query::Alias* temp = _impl_.alias_; _impl_.alias_ = nullptr; return temp; } inline ::pg_query::Alias* RangeVar::_internal_mutable_alias() { if (_impl_.alias_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Alias>(GetArenaForAllocation()); _impl_.alias_ = p; } return _impl_.alias_; } inline ::pg_query::Alias* RangeVar::mutable_alias() { ::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* alias) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.alias_; } if (alias) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(alias); if (message_arena != submessage_arena) { alias = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, alias, submessage_arena); } } else { } _impl_.alias_ = alias; // @@protoc_insertion_point(field_set_allocated:pg_query.RangeVar.alias) } // int32 location = 7 [json_name = "location"]; inline void RangeVar::clear_location() { _impl_.location_ = 0; } inline int32_t RangeVar::_internal_location() const { return _impl_.location_; } inline int32_t RangeVar::location() const { // @@protoc_insertion_point(field_get:pg_query.RangeVar.location) return _internal_location(); } inline void RangeVar::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void RangeVar::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.RangeVar.location) } // ------------------------------------------------------------------- // TableFunc // repeated .pg_query.Node ns_uris = 1 [json_name = "ns_uris"]; inline int TableFunc::_internal_ns_uris_size() const { return _impl_.ns_uris_.size(); } inline int TableFunc::ns_uris_size() const { return _internal_ns_uris_size(); } inline void TableFunc::clear_ns_uris() { _impl_.ns_uris_.Clear(); } inline ::pg_query::Node* TableFunc::mutable_ns_uris(int index) { // @@protoc_insertion_point(field_mutable:pg_query.TableFunc.ns_uris) return _impl_.ns_uris_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* TableFunc::mutable_ns_uris() { // @@protoc_insertion_point(field_mutable_list:pg_query.TableFunc.ns_uris) return &_impl_.ns_uris_; } inline const ::pg_query::Node& TableFunc::_internal_ns_uris(int index) const { return _impl_.ns_uris_.Get(index); } inline const ::pg_query::Node& TableFunc::ns_uris(int index) const { // @@protoc_insertion_point(field_get:pg_query.TableFunc.ns_uris) return _internal_ns_uris(index); } inline ::pg_query::Node* TableFunc::_internal_add_ns_uris() { return _impl_.ns_uris_.Add(); } inline ::pg_query::Node* TableFunc::add_ns_uris() { ::pg_query::Node* _add = _internal_add_ns_uris(); // @@protoc_insertion_point(field_add:pg_query.TableFunc.ns_uris) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& TableFunc::ns_uris() const { // @@protoc_insertion_point(field_list:pg_query.TableFunc.ns_uris) return _impl_.ns_uris_; } // repeated .pg_query.Node ns_names = 2 [json_name = "ns_names"]; inline int TableFunc::_internal_ns_names_size() const { return _impl_.ns_names_.size(); } inline int TableFunc::ns_names_size() const { return _internal_ns_names_size(); } inline void TableFunc::clear_ns_names() { _impl_.ns_names_.Clear(); } inline ::pg_query::Node* TableFunc::mutable_ns_names(int index) { // @@protoc_insertion_point(field_mutable:pg_query.TableFunc.ns_names) return _impl_.ns_names_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* TableFunc::mutable_ns_names() { // @@protoc_insertion_point(field_mutable_list:pg_query.TableFunc.ns_names) return &_impl_.ns_names_; } inline const ::pg_query::Node& TableFunc::_internal_ns_names(int index) const { return _impl_.ns_names_.Get(index); } inline const ::pg_query::Node& TableFunc::ns_names(int index) const { // @@protoc_insertion_point(field_get:pg_query.TableFunc.ns_names) return _internal_ns_names(index); } inline ::pg_query::Node* TableFunc::_internal_add_ns_names() { return _impl_.ns_names_.Add(); } inline ::pg_query::Node* TableFunc::add_ns_names() { ::pg_query::Node* _add = _internal_add_ns_names(); // @@protoc_insertion_point(field_add:pg_query.TableFunc.ns_names) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& TableFunc::ns_names() const { // @@protoc_insertion_point(field_list:pg_query.TableFunc.ns_names) return _impl_.ns_names_; } // .pg_query.Node docexpr = 3 [json_name = "docexpr"]; inline bool TableFunc::_internal_has_docexpr() const { return this != internal_default_instance() && _impl_.docexpr_ != nullptr; } inline bool TableFunc::has_docexpr() const { return _internal_has_docexpr(); } inline void TableFunc::clear_docexpr() { if (GetArenaForAllocation() == nullptr && _impl_.docexpr_ != nullptr) { delete _impl_.docexpr_; } _impl_.docexpr_ = nullptr; } inline const ::pg_query::Node& TableFunc::_internal_docexpr() const { const ::pg_query::Node* p = _impl_.docexpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& TableFunc::docexpr() const { // @@protoc_insertion_point(field_get:pg_query.TableFunc.docexpr) return _internal_docexpr(); } inline void TableFunc::unsafe_arena_set_allocated_docexpr( ::pg_query::Node* docexpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.docexpr_); } _impl_.docexpr_ = docexpr; if (docexpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.TableFunc.docexpr) } inline ::pg_query::Node* TableFunc::release_docexpr() { ::pg_query::Node* temp = _impl_.docexpr_; _impl_.docexpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* TableFunc::unsafe_arena_release_docexpr() { // @@protoc_insertion_point(field_release:pg_query.TableFunc.docexpr) ::pg_query::Node* temp = _impl_.docexpr_; _impl_.docexpr_ = nullptr; return temp; } inline ::pg_query::Node* TableFunc::_internal_mutable_docexpr() { if (_impl_.docexpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.docexpr_ = p; } return _impl_.docexpr_; } inline ::pg_query::Node* TableFunc::mutable_docexpr() { ::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* docexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.docexpr_; } if (docexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(docexpr); if (message_arena != submessage_arena) { docexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, docexpr, submessage_arena); } } else { } _impl_.docexpr_ = docexpr; // @@protoc_insertion_point(field_set_allocated:pg_query.TableFunc.docexpr) } // .pg_query.Node rowexpr = 4 [json_name = "rowexpr"]; inline bool TableFunc::_internal_has_rowexpr() const { return this != internal_default_instance() && _impl_.rowexpr_ != nullptr; } inline bool TableFunc::has_rowexpr() const { return _internal_has_rowexpr(); } inline void TableFunc::clear_rowexpr() { if (GetArenaForAllocation() == nullptr && _impl_.rowexpr_ != nullptr) { delete _impl_.rowexpr_; } _impl_.rowexpr_ = nullptr; } inline const ::pg_query::Node& TableFunc::_internal_rowexpr() const { const ::pg_query::Node* p = _impl_.rowexpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& TableFunc::rowexpr() const { // @@protoc_insertion_point(field_get:pg_query.TableFunc.rowexpr) return _internal_rowexpr(); } inline void TableFunc::unsafe_arena_set_allocated_rowexpr( ::pg_query::Node* rowexpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.rowexpr_); } _impl_.rowexpr_ = rowexpr; if (rowexpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.TableFunc.rowexpr) } inline ::pg_query::Node* TableFunc::release_rowexpr() { ::pg_query::Node* temp = _impl_.rowexpr_; _impl_.rowexpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* TableFunc::unsafe_arena_release_rowexpr() { // @@protoc_insertion_point(field_release:pg_query.TableFunc.rowexpr) ::pg_query::Node* temp = _impl_.rowexpr_; _impl_.rowexpr_ = nullptr; return temp; } inline ::pg_query::Node* TableFunc::_internal_mutable_rowexpr() { if (_impl_.rowexpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.rowexpr_ = p; } return _impl_.rowexpr_; } inline ::pg_query::Node* TableFunc::mutable_rowexpr() { ::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* rowexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.rowexpr_; } if (rowexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(rowexpr); if (message_arena != submessage_arena) { rowexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, rowexpr, submessage_arena); } } else { } _impl_.rowexpr_ = rowexpr; // @@protoc_insertion_point(field_set_allocated:pg_query.TableFunc.rowexpr) } // repeated .pg_query.Node colnames = 5 [json_name = "colnames"]; inline int TableFunc::_internal_colnames_size() const { return _impl_.colnames_.size(); } inline int TableFunc::colnames_size() const { return _internal_colnames_size(); } inline void TableFunc::clear_colnames() { _impl_.colnames_.Clear(); } inline ::pg_query::Node* TableFunc::mutable_colnames(int index) { // @@protoc_insertion_point(field_mutable:pg_query.TableFunc.colnames) return _impl_.colnames_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* TableFunc::mutable_colnames() { // @@protoc_insertion_point(field_mutable_list:pg_query.TableFunc.colnames) return &_impl_.colnames_; } inline const ::pg_query::Node& TableFunc::_internal_colnames(int index) const { return _impl_.colnames_.Get(index); } inline const ::pg_query::Node& TableFunc::colnames(int index) const { // @@protoc_insertion_point(field_get:pg_query.TableFunc.colnames) return _internal_colnames(index); } inline ::pg_query::Node* TableFunc::_internal_add_colnames() { return _impl_.colnames_.Add(); } inline ::pg_query::Node* TableFunc::add_colnames() { ::pg_query::Node* _add = _internal_add_colnames(); // @@protoc_insertion_point(field_add:pg_query.TableFunc.colnames) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& TableFunc::colnames() const { // @@protoc_insertion_point(field_list:pg_query.TableFunc.colnames) return _impl_.colnames_; } // repeated .pg_query.Node coltypes = 6 [json_name = "coltypes"]; inline int TableFunc::_internal_coltypes_size() const { return _impl_.coltypes_.size(); } inline int TableFunc::coltypes_size() const { return _internal_coltypes_size(); } inline void TableFunc::clear_coltypes() { _impl_.coltypes_.Clear(); } inline ::pg_query::Node* TableFunc::mutable_coltypes(int index) { // @@protoc_insertion_point(field_mutable:pg_query.TableFunc.coltypes) return _impl_.coltypes_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* TableFunc::mutable_coltypes() { // @@protoc_insertion_point(field_mutable_list:pg_query.TableFunc.coltypes) return &_impl_.coltypes_; } inline const ::pg_query::Node& TableFunc::_internal_coltypes(int index) const { return _impl_.coltypes_.Get(index); } inline const ::pg_query::Node& TableFunc::coltypes(int index) const { // @@protoc_insertion_point(field_get:pg_query.TableFunc.coltypes) return _internal_coltypes(index); } inline ::pg_query::Node* TableFunc::_internal_add_coltypes() { return _impl_.coltypes_.Add(); } inline ::pg_query::Node* TableFunc::add_coltypes() { ::pg_query::Node* _add = _internal_add_coltypes(); // @@protoc_insertion_point(field_add:pg_query.TableFunc.coltypes) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& TableFunc::coltypes() const { // @@protoc_insertion_point(field_list:pg_query.TableFunc.coltypes) return _impl_.coltypes_; } // repeated .pg_query.Node coltypmods = 7 [json_name = "coltypmods"]; inline int TableFunc::_internal_coltypmods_size() const { return _impl_.coltypmods_.size(); } inline int TableFunc::coltypmods_size() const { return _internal_coltypmods_size(); } inline void TableFunc::clear_coltypmods() { _impl_.coltypmods_.Clear(); } inline ::pg_query::Node* TableFunc::mutable_coltypmods(int index) { // @@protoc_insertion_point(field_mutable:pg_query.TableFunc.coltypmods) return _impl_.coltypmods_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* TableFunc::mutable_coltypmods() { // @@protoc_insertion_point(field_mutable_list:pg_query.TableFunc.coltypmods) return &_impl_.coltypmods_; } inline const ::pg_query::Node& TableFunc::_internal_coltypmods(int index) const { return _impl_.coltypmods_.Get(index); } inline const ::pg_query::Node& TableFunc::coltypmods(int index) const { // @@protoc_insertion_point(field_get:pg_query.TableFunc.coltypmods) return _internal_coltypmods(index); } inline ::pg_query::Node* TableFunc::_internal_add_coltypmods() { return _impl_.coltypmods_.Add(); } inline ::pg_query::Node* TableFunc::add_coltypmods() { ::pg_query::Node* _add = _internal_add_coltypmods(); // @@protoc_insertion_point(field_add:pg_query.TableFunc.coltypmods) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& TableFunc::coltypmods() const { // @@protoc_insertion_point(field_list:pg_query.TableFunc.coltypmods) return _impl_.coltypmods_; } // repeated .pg_query.Node colcollations = 8 [json_name = "colcollations"]; inline int TableFunc::_internal_colcollations_size() const { return _impl_.colcollations_.size(); } inline int TableFunc::colcollations_size() const { return _internal_colcollations_size(); } inline void TableFunc::clear_colcollations() { _impl_.colcollations_.Clear(); } inline ::pg_query::Node* TableFunc::mutable_colcollations(int index) { // @@protoc_insertion_point(field_mutable:pg_query.TableFunc.colcollations) return _impl_.colcollations_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* TableFunc::mutable_colcollations() { // @@protoc_insertion_point(field_mutable_list:pg_query.TableFunc.colcollations) return &_impl_.colcollations_; } inline const ::pg_query::Node& TableFunc::_internal_colcollations(int index) const { return _impl_.colcollations_.Get(index); } inline const ::pg_query::Node& TableFunc::colcollations(int index) const { // @@protoc_insertion_point(field_get:pg_query.TableFunc.colcollations) return _internal_colcollations(index); } inline ::pg_query::Node* TableFunc::_internal_add_colcollations() { return _impl_.colcollations_.Add(); } inline ::pg_query::Node* TableFunc::add_colcollations() { ::pg_query::Node* _add = _internal_add_colcollations(); // @@protoc_insertion_point(field_add:pg_query.TableFunc.colcollations) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& TableFunc::colcollations() const { // @@protoc_insertion_point(field_list:pg_query.TableFunc.colcollations) return _impl_.colcollations_; } // repeated .pg_query.Node colexprs = 9 [json_name = "colexprs"]; inline int TableFunc::_internal_colexprs_size() const { return _impl_.colexprs_.size(); } inline int TableFunc::colexprs_size() const { return _internal_colexprs_size(); } inline void TableFunc::clear_colexprs() { _impl_.colexprs_.Clear(); } inline ::pg_query::Node* TableFunc::mutable_colexprs(int index) { // @@protoc_insertion_point(field_mutable:pg_query.TableFunc.colexprs) return _impl_.colexprs_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* TableFunc::mutable_colexprs() { // @@protoc_insertion_point(field_mutable_list:pg_query.TableFunc.colexprs) return &_impl_.colexprs_; } inline const ::pg_query::Node& TableFunc::_internal_colexprs(int index) const { return _impl_.colexprs_.Get(index); } inline const ::pg_query::Node& TableFunc::colexprs(int index) const { // @@protoc_insertion_point(field_get:pg_query.TableFunc.colexprs) return _internal_colexprs(index); } inline ::pg_query::Node* TableFunc::_internal_add_colexprs() { return _impl_.colexprs_.Add(); } inline ::pg_query::Node* TableFunc::add_colexprs() { ::pg_query::Node* _add = _internal_add_colexprs(); // @@protoc_insertion_point(field_add:pg_query.TableFunc.colexprs) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& TableFunc::colexprs() const { // @@protoc_insertion_point(field_list:pg_query.TableFunc.colexprs) return _impl_.colexprs_; } // repeated .pg_query.Node coldefexprs = 10 [json_name = "coldefexprs"]; inline int TableFunc::_internal_coldefexprs_size() const { return _impl_.coldefexprs_.size(); } inline int TableFunc::coldefexprs_size() const { return _internal_coldefexprs_size(); } inline void TableFunc::clear_coldefexprs() { _impl_.coldefexprs_.Clear(); } inline ::pg_query::Node* TableFunc::mutable_coldefexprs(int index) { // @@protoc_insertion_point(field_mutable:pg_query.TableFunc.coldefexprs) return _impl_.coldefexprs_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* TableFunc::mutable_coldefexprs() { // @@protoc_insertion_point(field_mutable_list:pg_query.TableFunc.coldefexprs) return &_impl_.coldefexprs_; } inline const ::pg_query::Node& TableFunc::_internal_coldefexprs(int index) const { return _impl_.coldefexprs_.Get(index); } inline const ::pg_query::Node& TableFunc::coldefexprs(int index) const { // @@protoc_insertion_point(field_get:pg_query.TableFunc.coldefexprs) return _internal_coldefexprs(index); } inline ::pg_query::Node* TableFunc::_internal_add_coldefexprs() { return _impl_.coldefexprs_.Add(); } inline ::pg_query::Node* TableFunc::add_coldefexprs() { ::pg_query::Node* _add = _internal_add_coldefexprs(); // @@protoc_insertion_point(field_add:pg_query.TableFunc.coldefexprs) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& TableFunc::coldefexprs() const { // @@protoc_insertion_point(field_list:pg_query.TableFunc.coldefexprs) return _impl_.coldefexprs_; } // repeated uint64 notnulls = 11 [json_name = "notnulls"]; inline int TableFunc::_internal_notnulls_size() const { return _impl_.notnulls_.size(); } inline int TableFunc::notnulls_size() const { return _internal_notnulls_size(); } inline void TableFunc::clear_notnulls() { _impl_.notnulls_.Clear(); } inline uint64_t TableFunc::_internal_notnulls(int index) const { return _impl_.notnulls_.Get(index); } inline uint64_t TableFunc::notnulls(int index) const { // @@protoc_insertion_point(field_get:pg_query.TableFunc.notnulls) return _internal_notnulls(index); } inline void TableFunc::set_notnulls(int index, uint64_t value) { _impl_.notnulls_.Set(index, value); // @@protoc_insertion_point(field_set:pg_query.TableFunc.notnulls) } inline void TableFunc::_internal_add_notnulls(uint64_t value) { _impl_.notnulls_.Add(value); } inline void TableFunc::add_notnulls(uint64_t value) { _internal_add_notnulls(value); // @@protoc_insertion_point(field_add:pg_query.TableFunc.notnulls) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >& TableFunc::_internal_notnulls() const { return _impl_.notnulls_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >& TableFunc::notnulls() const { // @@protoc_insertion_point(field_list:pg_query.TableFunc.notnulls) return _internal_notnulls(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >* TableFunc::_internal_mutable_notnulls() { return &_impl_.notnulls_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >* TableFunc::mutable_notnulls() { // @@protoc_insertion_point(field_mutable_list:pg_query.TableFunc.notnulls) return _internal_mutable_notnulls(); } // int32 ordinalitycol = 12 [json_name = "ordinalitycol"]; inline void TableFunc::clear_ordinalitycol() { _impl_.ordinalitycol_ = 0; } inline int32_t TableFunc::_internal_ordinalitycol() const { return _impl_.ordinalitycol_; } inline int32_t TableFunc::ordinalitycol() const { // @@protoc_insertion_point(field_get:pg_query.TableFunc.ordinalitycol) return _internal_ordinalitycol(); } inline void TableFunc::_internal_set_ordinalitycol(int32_t value) { _impl_.ordinalitycol_ = value; } inline void TableFunc::set_ordinalitycol(int32_t value) { _internal_set_ordinalitycol(value); // @@protoc_insertion_point(field_set:pg_query.TableFunc.ordinalitycol) } // int32 location = 13 [json_name = "location"]; inline void TableFunc::clear_location() { _impl_.location_ = 0; } inline int32_t TableFunc::_internal_location() const { return _impl_.location_; } inline int32_t TableFunc::location() const { // @@protoc_insertion_point(field_get:pg_query.TableFunc.location) return _internal_location(); } inline void TableFunc::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void TableFunc::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.TableFunc.location) } // ------------------------------------------------------------------- // Var // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool Var::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool Var::has_xpr() const { return _internal_has_xpr(); } inline void Var::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& Var::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& Var::xpr() const { // @@protoc_insertion_point(field_get:pg_query.Var.xpr) return _internal_xpr(); } inline void Var::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Var.xpr) } inline ::pg_query::Node* Var::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* Var::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.Var.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* Var::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* Var::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.Var.xpr) } // int32 varno = 2 [json_name = "varno"]; inline void Var::clear_varno() { _impl_.varno_ = 0; } inline int32_t Var::_internal_varno() const { return _impl_.varno_; } inline int32_t Var::varno() const { // @@protoc_insertion_point(field_get:pg_query.Var.varno) return _internal_varno(); } inline void Var::_internal_set_varno(int32_t value) { _impl_.varno_ = value; } inline void Var::set_varno(int32_t value) { _internal_set_varno(value); // @@protoc_insertion_point(field_set:pg_query.Var.varno) } // int32 varattno = 3 [json_name = "varattno"]; inline void Var::clear_varattno() { _impl_.varattno_ = 0; } inline int32_t Var::_internal_varattno() const { return _impl_.varattno_; } inline int32_t Var::varattno() const { // @@protoc_insertion_point(field_get:pg_query.Var.varattno) return _internal_varattno(); } inline void Var::_internal_set_varattno(int32_t value) { _impl_.varattno_ = value; } inline void Var::set_varattno(int32_t value) { _internal_set_varattno(value); // @@protoc_insertion_point(field_set:pg_query.Var.varattno) } // uint32 vartype = 4 [json_name = "vartype"]; inline void Var::clear_vartype() { _impl_.vartype_ = 0u; } inline uint32_t Var::_internal_vartype() const { return _impl_.vartype_; } inline uint32_t Var::vartype() const { // @@protoc_insertion_point(field_get:pg_query.Var.vartype) return _internal_vartype(); } inline void Var::_internal_set_vartype(uint32_t value) { _impl_.vartype_ = value; } inline void Var::set_vartype(uint32_t value) { _internal_set_vartype(value); // @@protoc_insertion_point(field_set:pg_query.Var.vartype) } // int32 vartypmod = 5 [json_name = "vartypmod"]; inline void Var::clear_vartypmod() { _impl_.vartypmod_ = 0; } inline int32_t Var::_internal_vartypmod() const { return _impl_.vartypmod_; } inline int32_t Var::vartypmod() const { // @@protoc_insertion_point(field_get:pg_query.Var.vartypmod) return _internal_vartypmod(); } inline void Var::_internal_set_vartypmod(int32_t value) { _impl_.vartypmod_ = value; } inline void Var::set_vartypmod(int32_t value) { _internal_set_vartypmod(value); // @@protoc_insertion_point(field_set:pg_query.Var.vartypmod) } // uint32 varcollid = 6 [json_name = "varcollid"]; inline void Var::clear_varcollid() { _impl_.varcollid_ = 0u; } inline uint32_t Var::_internal_varcollid() const { return _impl_.varcollid_; } inline uint32_t Var::varcollid() const { // @@protoc_insertion_point(field_get:pg_query.Var.varcollid) return _internal_varcollid(); } inline void Var::_internal_set_varcollid(uint32_t value) { _impl_.varcollid_ = value; } inline void Var::set_varcollid(uint32_t value) { _internal_set_varcollid(value); // @@protoc_insertion_point(field_set:pg_query.Var.varcollid) } // uint32 varlevelsup = 7 [json_name = "varlevelsup"]; inline void Var::clear_varlevelsup() { _impl_.varlevelsup_ = 0u; } inline uint32_t Var::_internal_varlevelsup() const { return _impl_.varlevelsup_; } inline uint32_t Var::varlevelsup() const { // @@protoc_insertion_point(field_get:pg_query.Var.varlevelsup) return _internal_varlevelsup(); } inline void Var::_internal_set_varlevelsup(uint32_t value) { _impl_.varlevelsup_ = value; } inline void Var::set_varlevelsup(uint32_t value) { _internal_set_varlevelsup(value); // @@protoc_insertion_point(field_set:pg_query.Var.varlevelsup) } // uint32 varnosyn = 8 [json_name = "varnosyn"]; inline void Var::clear_varnosyn() { _impl_.varnosyn_ = 0u; } inline uint32_t Var::_internal_varnosyn() const { return _impl_.varnosyn_; } inline uint32_t Var::varnosyn() const { // @@protoc_insertion_point(field_get:pg_query.Var.varnosyn) return _internal_varnosyn(); } inline void Var::_internal_set_varnosyn(uint32_t value) { _impl_.varnosyn_ = value; } inline void Var::set_varnosyn(uint32_t value) { _internal_set_varnosyn(value); // @@protoc_insertion_point(field_set:pg_query.Var.varnosyn) } // int32 varattnosyn = 9 [json_name = "varattnosyn"]; inline void Var::clear_varattnosyn() { _impl_.varattnosyn_ = 0; } inline int32_t Var::_internal_varattnosyn() const { return _impl_.varattnosyn_; } inline int32_t Var::varattnosyn() const { // @@protoc_insertion_point(field_get:pg_query.Var.varattnosyn) return _internal_varattnosyn(); } inline void Var::_internal_set_varattnosyn(int32_t value) { _impl_.varattnosyn_ = value; } inline void Var::set_varattnosyn(int32_t value) { _internal_set_varattnosyn(value); // @@protoc_insertion_point(field_set:pg_query.Var.varattnosyn) } // int32 location = 10 [json_name = "location"]; inline void Var::clear_location() { _impl_.location_ = 0; } inline int32_t Var::_internal_location() const { return _impl_.location_; } inline int32_t Var::location() const { // @@protoc_insertion_point(field_get:pg_query.Var.location) return _internal_location(); } inline void Var::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void Var::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.Var.location) } // ------------------------------------------------------------------- // Param // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool Param::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool Param::has_xpr() const { return _internal_has_xpr(); } inline void Param::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& Param::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& Param::xpr() const { // @@protoc_insertion_point(field_get:pg_query.Param.xpr) return _internal_xpr(); } inline void Param::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Param.xpr) } inline ::pg_query::Node* Param::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* Param::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.Param.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* Param::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* Param::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.Param.xpr) } // .pg_query.ParamKind paramkind = 2 [json_name = "paramkind"]; inline void Param::clear_paramkind() { _impl_.paramkind_ = 0; } inline ::pg_query::ParamKind Param::_internal_paramkind() const { return static_cast< ::pg_query::ParamKind >(_impl_.paramkind_); } inline ::pg_query::ParamKind Param::paramkind() const { // @@protoc_insertion_point(field_get:pg_query.Param.paramkind) return _internal_paramkind(); } inline void Param::_internal_set_paramkind(::pg_query::ParamKind value) { _impl_.paramkind_ = value; } inline void Param::set_paramkind(::pg_query::ParamKind value) { _internal_set_paramkind(value); // @@protoc_insertion_point(field_set:pg_query.Param.paramkind) } // int32 paramid = 3 [json_name = "paramid"]; inline void Param::clear_paramid() { _impl_.paramid_ = 0; } inline int32_t Param::_internal_paramid() const { return _impl_.paramid_; } inline int32_t Param::paramid() const { // @@protoc_insertion_point(field_get:pg_query.Param.paramid) return _internal_paramid(); } inline void Param::_internal_set_paramid(int32_t value) { _impl_.paramid_ = value; } inline void Param::set_paramid(int32_t value) { _internal_set_paramid(value); // @@protoc_insertion_point(field_set:pg_query.Param.paramid) } // uint32 paramtype = 4 [json_name = "paramtype"]; inline void Param::clear_paramtype() { _impl_.paramtype_ = 0u; } inline uint32_t Param::_internal_paramtype() const { return _impl_.paramtype_; } inline uint32_t Param::paramtype() const { // @@protoc_insertion_point(field_get:pg_query.Param.paramtype) return _internal_paramtype(); } inline void Param::_internal_set_paramtype(uint32_t value) { _impl_.paramtype_ = value; } inline void Param::set_paramtype(uint32_t value) { _internal_set_paramtype(value); // @@protoc_insertion_point(field_set:pg_query.Param.paramtype) } // int32 paramtypmod = 5 [json_name = "paramtypmod"]; inline void Param::clear_paramtypmod() { _impl_.paramtypmod_ = 0; } inline int32_t Param::_internal_paramtypmod() const { return _impl_.paramtypmod_; } inline int32_t Param::paramtypmod() const { // @@protoc_insertion_point(field_get:pg_query.Param.paramtypmod) return _internal_paramtypmod(); } inline void Param::_internal_set_paramtypmod(int32_t value) { _impl_.paramtypmod_ = value; } inline void Param::set_paramtypmod(int32_t value) { _internal_set_paramtypmod(value); // @@protoc_insertion_point(field_set:pg_query.Param.paramtypmod) } // uint32 paramcollid = 6 [json_name = "paramcollid"]; inline void Param::clear_paramcollid() { _impl_.paramcollid_ = 0u; } inline uint32_t Param::_internal_paramcollid() const { return _impl_.paramcollid_; } inline uint32_t Param::paramcollid() const { // @@protoc_insertion_point(field_get:pg_query.Param.paramcollid) return _internal_paramcollid(); } inline void Param::_internal_set_paramcollid(uint32_t value) { _impl_.paramcollid_ = value; } inline void Param::set_paramcollid(uint32_t value) { _internal_set_paramcollid(value); // @@protoc_insertion_point(field_set:pg_query.Param.paramcollid) } // int32 location = 7 [json_name = "location"]; inline void Param::clear_location() { _impl_.location_ = 0; } inline int32_t Param::_internal_location() const { return _impl_.location_; } inline int32_t Param::location() const { // @@protoc_insertion_point(field_get:pg_query.Param.location) return _internal_location(); } inline void Param::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void Param::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.Param.location) } // ------------------------------------------------------------------- // Aggref // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool Aggref::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool Aggref::has_xpr() const { return _internal_has_xpr(); } inline void Aggref::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& Aggref::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& Aggref::xpr() const { // @@protoc_insertion_point(field_get:pg_query.Aggref.xpr) return _internal_xpr(); } inline void Aggref::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Aggref.xpr) } inline ::pg_query::Node* Aggref::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* Aggref::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.Aggref.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* Aggref::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* Aggref::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.Aggref.xpr) } // uint32 aggfnoid = 2 [json_name = "aggfnoid"]; inline void Aggref::clear_aggfnoid() { _impl_.aggfnoid_ = 0u; } inline uint32_t Aggref::_internal_aggfnoid() const { return _impl_.aggfnoid_; } inline uint32_t Aggref::aggfnoid() const { // @@protoc_insertion_point(field_get:pg_query.Aggref.aggfnoid) return _internal_aggfnoid(); } inline void Aggref::_internal_set_aggfnoid(uint32_t value) { _impl_.aggfnoid_ = value; } inline void Aggref::set_aggfnoid(uint32_t value) { _internal_set_aggfnoid(value); // @@protoc_insertion_point(field_set:pg_query.Aggref.aggfnoid) } // uint32 aggtype = 3 [json_name = "aggtype"]; inline void Aggref::clear_aggtype() { _impl_.aggtype_ = 0u; } inline uint32_t Aggref::_internal_aggtype() const { return _impl_.aggtype_; } inline uint32_t Aggref::aggtype() const { // @@protoc_insertion_point(field_get:pg_query.Aggref.aggtype) return _internal_aggtype(); } inline void Aggref::_internal_set_aggtype(uint32_t value) { _impl_.aggtype_ = value; } inline void Aggref::set_aggtype(uint32_t value) { _internal_set_aggtype(value); // @@protoc_insertion_point(field_set:pg_query.Aggref.aggtype) } // uint32 aggcollid = 4 [json_name = "aggcollid"]; inline void Aggref::clear_aggcollid() { _impl_.aggcollid_ = 0u; } inline uint32_t Aggref::_internal_aggcollid() const { return _impl_.aggcollid_; } inline uint32_t Aggref::aggcollid() const { // @@protoc_insertion_point(field_get:pg_query.Aggref.aggcollid) return _internal_aggcollid(); } inline void Aggref::_internal_set_aggcollid(uint32_t value) { _impl_.aggcollid_ = value; } inline void Aggref::set_aggcollid(uint32_t value) { _internal_set_aggcollid(value); // @@protoc_insertion_point(field_set:pg_query.Aggref.aggcollid) } // uint32 inputcollid = 5 [json_name = "inputcollid"]; inline void Aggref::clear_inputcollid() { _impl_.inputcollid_ = 0u; } inline uint32_t Aggref::_internal_inputcollid() const { return _impl_.inputcollid_; } inline uint32_t Aggref::inputcollid() const { // @@protoc_insertion_point(field_get:pg_query.Aggref.inputcollid) return _internal_inputcollid(); } inline void Aggref::_internal_set_inputcollid(uint32_t value) { _impl_.inputcollid_ = value; } inline void Aggref::set_inputcollid(uint32_t value) { _internal_set_inputcollid(value); // @@protoc_insertion_point(field_set:pg_query.Aggref.inputcollid) } // uint32 aggtranstype = 6 [json_name = "aggtranstype"]; inline void Aggref::clear_aggtranstype() { _impl_.aggtranstype_ = 0u; } inline uint32_t Aggref::_internal_aggtranstype() const { return _impl_.aggtranstype_; } inline uint32_t Aggref::aggtranstype() const { // @@protoc_insertion_point(field_get:pg_query.Aggref.aggtranstype) return _internal_aggtranstype(); } inline void Aggref::_internal_set_aggtranstype(uint32_t value) { _impl_.aggtranstype_ = value; } inline void Aggref::set_aggtranstype(uint32_t value) { _internal_set_aggtranstype(value); // @@protoc_insertion_point(field_set:pg_query.Aggref.aggtranstype) } // repeated .pg_query.Node aggargtypes = 7 [json_name = "aggargtypes"]; inline int Aggref::_internal_aggargtypes_size() const { return _impl_.aggargtypes_.size(); } inline int Aggref::aggargtypes_size() const { return _internal_aggargtypes_size(); } inline void Aggref::clear_aggargtypes() { _impl_.aggargtypes_.Clear(); } inline ::pg_query::Node* Aggref::mutable_aggargtypes(int index) { // @@protoc_insertion_point(field_mutable:pg_query.Aggref.aggargtypes) return _impl_.aggargtypes_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* Aggref::mutable_aggargtypes() { // @@protoc_insertion_point(field_mutable_list:pg_query.Aggref.aggargtypes) return &_impl_.aggargtypes_; } inline const ::pg_query::Node& Aggref::_internal_aggargtypes(int index) const { return _impl_.aggargtypes_.Get(index); } inline const ::pg_query::Node& Aggref::aggargtypes(int index) const { // @@protoc_insertion_point(field_get:pg_query.Aggref.aggargtypes) return _internal_aggargtypes(index); } inline ::pg_query::Node* Aggref::_internal_add_aggargtypes() { return _impl_.aggargtypes_.Add(); } inline ::pg_query::Node* Aggref::add_aggargtypes() { ::pg_query::Node* _add = _internal_add_aggargtypes(); // @@protoc_insertion_point(field_add:pg_query.Aggref.aggargtypes) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& Aggref::aggargtypes() const { // @@protoc_insertion_point(field_list:pg_query.Aggref.aggargtypes) return _impl_.aggargtypes_; } // repeated .pg_query.Node aggdirectargs = 8 [json_name = "aggdirectargs"]; inline int Aggref::_internal_aggdirectargs_size() const { return _impl_.aggdirectargs_.size(); } inline int Aggref::aggdirectargs_size() const { return _internal_aggdirectargs_size(); } inline void Aggref::clear_aggdirectargs() { _impl_.aggdirectargs_.Clear(); } inline ::pg_query::Node* Aggref::mutable_aggdirectargs(int index) { // @@protoc_insertion_point(field_mutable:pg_query.Aggref.aggdirectargs) return _impl_.aggdirectargs_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* Aggref::mutable_aggdirectargs() { // @@protoc_insertion_point(field_mutable_list:pg_query.Aggref.aggdirectargs) return &_impl_.aggdirectargs_; } inline const ::pg_query::Node& Aggref::_internal_aggdirectargs(int index) const { return _impl_.aggdirectargs_.Get(index); } inline const ::pg_query::Node& Aggref::aggdirectargs(int index) const { // @@protoc_insertion_point(field_get:pg_query.Aggref.aggdirectargs) return _internal_aggdirectargs(index); } inline ::pg_query::Node* Aggref::_internal_add_aggdirectargs() { return _impl_.aggdirectargs_.Add(); } inline ::pg_query::Node* Aggref::add_aggdirectargs() { ::pg_query::Node* _add = _internal_add_aggdirectargs(); // @@protoc_insertion_point(field_add:pg_query.Aggref.aggdirectargs) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& Aggref::aggdirectargs() const { // @@protoc_insertion_point(field_list:pg_query.Aggref.aggdirectargs) return _impl_.aggdirectargs_; } // repeated .pg_query.Node args = 9 [json_name = "args"]; inline int Aggref::_internal_args_size() const { return _impl_.args_.size(); } inline int Aggref::args_size() const { return _internal_args_size(); } inline void Aggref::clear_args() { _impl_.args_.Clear(); } inline ::pg_query::Node* Aggref::mutable_args(int index) { // @@protoc_insertion_point(field_mutable:pg_query.Aggref.args) return _impl_.args_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* Aggref::mutable_args() { // @@protoc_insertion_point(field_mutable_list:pg_query.Aggref.args) return &_impl_.args_; } inline const ::pg_query::Node& Aggref::_internal_args(int index) const { return _impl_.args_.Get(index); } inline const ::pg_query::Node& Aggref::args(int index) const { // @@protoc_insertion_point(field_get:pg_query.Aggref.args) return _internal_args(index); } inline ::pg_query::Node* Aggref::_internal_add_args() { return _impl_.args_.Add(); } inline ::pg_query::Node* Aggref::add_args() { ::pg_query::Node* _add = _internal_add_args(); // @@protoc_insertion_point(field_add:pg_query.Aggref.args) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& Aggref::args() const { // @@protoc_insertion_point(field_list:pg_query.Aggref.args) return _impl_.args_; } // repeated .pg_query.Node aggorder = 10 [json_name = "aggorder"]; inline int Aggref::_internal_aggorder_size() const { return _impl_.aggorder_.size(); } inline int Aggref::aggorder_size() const { return _internal_aggorder_size(); } inline void Aggref::clear_aggorder() { _impl_.aggorder_.Clear(); } inline ::pg_query::Node* Aggref::mutable_aggorder(int index) { // @@protoc_insertion_point(field_mutable:pg_query.Aggref.aggorder) return _impl_.aggorder_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* Aggref::mutable_aggorder() { // @@protoc_insertion_point(field_mutable_list:pg_query.Aggref.aggorder) return &_impl_.aggorder_; } inline const ::pg_query::Node& Aggref::_internal_aggorder(int index) const { return _impl_.aggorder_.Get(index); } inline const ::pg_query::Node& Aggref::aggorder(int index) const { // @@protoc_insertion_point(field_get:pg_query.Aggref.aggorder) return _internal_aggorder(index); } inline ::pg_query::Node* Aggref::_internal_add_aggorder() { return _impl_.aggorder_.Add(); } inline ::pg_query::Node* Aggref::add_aggorder() { ::pg_query::Node* _add = _internal_add_aggorder(); // @@protoc_insertion_point(field_add:pg_query.Aggref.aggorder) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& Aggref::aggorder() const { // @@protoc_insertion_point(field_list:pg_query.Aggref.aggorder) return _impl_.aggorder_; } // repeated .pg_query.Node aggdistinct = 11 [json_name = "aggdistinct"]; inline int Aggref::_internal_aggdistinct_size() const { return _impl_.aggdistinct_.size(); } inline int Aggref::aggdistinct_size() const { return _internal_aggdistinct_size(); } inline void Aggref::clear_aggdistinct() { _impl_.aggdistinct_.Clear(); } inline ::pg_query::Node* Aggref::mutable_aggdistinct(int index) { // @@protoc_insertion_point(field_mutable:pg_query.Aggref.aggdistinct) return _impl_.aggdistinct_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* Aggref::mutable_aggdistinct() { // @@protoc_insertion_point(field_mutable_list:pg_query.Aggref.aggdistinct) return &_impl_.aggdistinct_; } inline const ::pg_query::Node& Aggref::_internal_aggdistinct(int index) const { return _impl_.aggdistinct_.Get(index); } inline const ::pg_query::Node& Aggref::aggdistinct(int index) const { // @@protoc_insertion_point(field_get:pg_query.Aggref.aggdistinct) return _internal_aggdistinct(index); } inline ::pg_query::Node* Aggref::_internal_add_aggdistinct() { return _impl_.aggdistinct_.Add(); } inline ::pg_query::Node* Aggref::add_aggdistinct() { ::pg_query::Node* _add = _internal_add_aggdistinct(); // @@protoc_insertion_point(field_add:pg_query.Aggref.aggdistinct) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& Aggref::aggdistinct() const { // @@protoc_insertion_point(field_list:pg_query.Aggref.aggdistinct) return _impl_.aggdistinct_; } // .pg_query.Node aggfilter = 12 [json_name = "aggfilter"]; inline bool Aggref::_internal_has_aggfilter() const { return this != internal_default_instance() && _impl_.aggfilter_ != nullptr; } inline bool Aggref::has_aggfilter() const { return _internal_has_aggfilter(); } inline void Aggref::clear_aggfilter() { if (GetArenaForAllocation() == nullptr && _impl_.aggfilter_ != nullptr) { delete _impl_.aggfilter_; } _impl_.aggfilter_ = nullptr; } inline const ::pg_query::Node& Aggref::_internal_aggfilter() const { const ::pg_query::Node* p = _impl_.aggfilter_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& Aggref::aggfilter() const { // @@protoc_insertion_point(field_get:pg_query.Aggref.aggfilter) return _internal_aggfilter(); } inline void Aggref::unsafe_arena_set_allocated_aggfilter( ::pg_query::Node* aggfilter) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.aggfilter_); } _impl_.aggfilter_ = aggfilter; if (aggfilter) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Aggref.aggfilter) } inline ::pg_query::Node* Aggref::release_aggfilter() { ::pg_query::Node* temp = _impl_.aggfilter_; _impl_.aggfilter_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* Aggref::unsafe_arena_release_aggfilter() { // @@protoc_insertion_point(field_release:pg_query.Aggref.aggfilter) ::pg_query::Node* temp = _impl_.aggfilter_; _impl_.aggfilter_ = nullptr; return temp; } inline ::pg_query::Node* Aggref::_internal_mutable_aggfilter() { if (_impl_.aggfilter_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.aggfilter_ = p; } return _impl_.aggfilter_; } inline ::pg_query::Node* Aggref::mutable_aggfilter() { ::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* aggfilter) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.aggfilter_; } if (aggfilter) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(aggfilter); if (message_arena != submessage_arena) { aggfilter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, aggfilter, submessage_arena); } } else { } _impl_.aggfilter_ = aggfilter; // @@protoc_insertion_point(field_set_allocated:pg_query.Aggref.aggfilter) } // bool aggstar = 13 [json_name = "aggstar"]; inline void Aggref::clear_aggstar() { _impl_.aggstar_ = false; } inline bool Aggref::_internal_aggstar() const { return _impl_.aggstar_; } inline bool Aggref::aggstar() const { // @@protoc_insertion_point(field_get:pg_query.Aggref.aggstar) return _internal_aggstar(); } inline void Aggref::_internal_set_aggstar(bool value) { _impl_.aggstar_ = value; } inline void Aggref::set_aggstar(bool value) { _internal_set_aggstar(value); // @@protoc_insertion_point(field_set:pg_query.Aggref.aggstar) } // bool aggvariadic = 14 [json_name = "aggvariadic"]; inline void Aggref::clear_aggvariadic() { _impl_.aggvariadic_ = false; } inline bool Aggref::_internal_aggvariadic() const { return _impl_.aggvariadic_; } inline bool Aggref::aggvariadic() const { // @@protoc_insertion_point(field_get:pg_query.Aggref.aggvariadic) return _internal_aggvariadic(); } inline void Aggref::_internal_set_aggvariadic(bool value) { _impl_.aggvariadic_ = value; } inline void Aggref::set_aggvariadic(bool value) { _internal_set_aggvariadic(value); // @@protoc_insertion_point(field_set:pg_query.Aggref.aggvariadic) } // string aggkind = 15 [json_name = "aggkind"]; inline void Aggref::clear_aggkind() { _impl_.aggkind_.ClearToEmpty(); } inline const std::string& Aggref::aggkind() const { // @@protoc_insertion_point(field_get:pg_query.Aggref.aggkind) return _internal_aggkind(); } template inline PROTOBUF_ALWAYS_INLINE void Aggref::set_aggkind(ArgT0&& arg0, ArgT... args) { _impl_.aggkind_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.Aggref.aggkind) } inline std::string* Aggref::mutable_aggkind() { 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 { return _impl_.aggkind_.Get(); } inline void Aggref::_internal_set_aggkind(const std::string& value) { _impl_.aggkind_.Set(value, GetArenaForAllocation()); } inline std::string* Aggref::_internal_mutable_aggkind() { return _impl_.aggkind_.Mutable(GetArenaForAllocation()); } inline std::string* Aggref::release_aggkind() { // @@protoc_insertion_point(field_release:pg_query.Aggref.aggkind) return _impl_.aggkind_.Release(); } inline void Aggref::set_allocated_aggkind(std::string* aggkind) { if (aggkind != nullptr) { } else { } _impl_.aggkind_.SetAllocated(aggkind, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.aggkind_.IsDefault()) { _impl_.aggkind_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:pg_query.Aggref.aggkind) } // uint32 agglevelsup = 16 [json_name = "agglevelsup"]; inline void Aggref::clear_agglevelsup() { _impl_.agglevelsup_ = 0u; } inline uint32_t Aggref::_internal_agglevelsup() const { return _impl_.agglevelsup_; } inline uint32_t Aggref::agglevelsup() const { // @@protoc_insertion_point(field_get:pg_query.Aggref.agglevelsup) return _internal_agglevelsup(); } inline void Aggref::_internal_set_agglevelsup(uint32_t value) { _impl_.agglevelsup_ = value; } inline void Aggref::set_agglevelsup(uint32_t value) { _internal_set_agglevelsup(value); // @@protoc_insertion_point(field_set:pg_query.Aggref.agglevelsup) } // .pg_query.AggSplit aggsplit = 17 [json_name = "aggsplit"]; inline void Aggref::clear_aggsplit() { _impl_.aggsplit_ = 0; } inline ::pg_query::AggSplit Aggref::_internal_aggsplit() const { return static_cast< ::pg_query::AggSplit >(_impl_.aggsplit_); } inline ::pg_query::AggSplit Aggref::aggsplit() const { // @@protoc_insertion_point(field_get:pg_query.Aggref.aggsplit) return _internal_aggsplit(); } inline void Aggref::_internal_set_aggsplit(::pg_query::AggSplit value) { _impl_.aggsplit_ = value; } inline void Aggref::set_aggsplit(::pg_query::AggSplit value) { _internal_set_aggsplit(value); // @@protoc_insertion_point(field_set:pg_query.Aggref.aggsplit) } // int32 aggno = 18 [json_name = "aggno"]; inline void Aggref::clear_aggno() { _impl_.aggno_ = 0; } inline int32_t Aggref::_internal_aggno() const { return _impl_.aggno_; } inline int32_t Aggref::aggno() const { // @@protoc_insertion_point(field_get:pg_query.Aggref.aggno) return _internal_aggno(); } inline void Aggref::_internal_set_aggno(int32_t value) { _impl_.aggno_ = value; } inline void Aggref::set_aggno(int32_t value) { _internal_set_aggno(value); // @@protoc_insertion_point(field_set:pg_query.Aggref.aggno) } // int32 aggtransno = 19 [json_name = "aggtransno"]; inline void Aggref::clear_aggtransno() { _impl_.aggtransno_ = 0; } inline int32_t Aggref::_internal_aggtransno() const { return _impl_.aggtransno_; } inline int32_t Aggref::aggtransno() const { // @@protoc_insertion_point(field_get:pg_query.Aggref.aggtransno) return _internal_aggtransno(); } inline void Aggref::_internal_set_aggtransno(int32_t value) { _impl_.aggtransno_ = value; } inline void Aggref::set_aggtransno(int32_t value) { _internal_set_aggtransno(value); // @@protoc_insertion_point(field_set:pg_query.Aggref.aggtransno) } // int32 location = 20 [json_name = "location"]; inline void Aggref::clear_location() { _impl_.location_ = 0; } inline int32_t Aggref::_internal_location() const { return _impl_.location_; } inline int32_t Aggref::location() const { // @@protoc_insertion_point(field_get:pg_query.Aggref.location) return _internal_location(); } inline void Aggref::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void Aggref::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.Aggref.location) } // ------------------------------------------------------------------- // GroupingFunc // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool GroupingFunc::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool GroupingFunc::has_xpr() const { return _internal_has_xpr(); } inline void GroupingFunc::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& GroupingFunc::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& GroupingFunc::xpr() const { // @@protoc_insertion_point(field_get:pg_query.GroupingFunc.xpr) return _internal_xpr(); } inline void GroupingFunc::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.GroupingFunc.xpr) } inline ::pg_query::Node* GroupingFunc::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* GroupingFunc::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.GroupingFunc.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* GroupingFunc::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* GroupingFunc::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.GroupingFunc.xpr) } // repeated .pg_query.Node args = 2 [json_name = "args"]; inline int GroupingFunc::_internal_args_size() const { return _impl_.args_.size(); } inline int GroupingFunc::args_size() const { return _internal_args_size(); } inline void GroupingFunc::clear_args() { _impl_.args_.Clear(); } inline ::pg_query::Node* GroupingFunc::mutable_args(int index) { // @@protoc_insertion_point(field_mutable:pg_query.GroupingFunc.args) return _impl_.args_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* GroupingFunc::mutable_args() { // @@protoc_insertion_point(field_mutable_list:pg_query.GroupingFunc.args) return &_impl_.args_; } inline const ::pg_query::Node& GroupingFunc::_internal_args(int index) const { return _impl_.args_.Get(index); } inline const ::pg_query::Node& GroupingFunc::args(int index) const { // @@protoc_insertion_point(field_get:pg_query.GroupingFunc.args) return _internal_args(index); } inline ::pg_query::Node* GroupingFunc::_internal_add_args() { return _impl_.args_.Add(); } inline ::pg_query::Node* GroupingFunc::add_args() { ::pg_query::Node* _add = _internal_add_args(); // @@protoc_insertion_point(field_add:pg_query.GroupingFunc.args) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& GroupingFunc::args() const { // @@protoc_insertion_point(field_list:pg_query.GroupingFunc.args) return _impl_.args_; } // repeated .pg_query.Node refs = 3 [json_name = "refs"]; inline int GroupingFunc::_internal_refs_size() const { return _impl_.refs_.size(); } inline int GroupingFunc::refs_size() const { return _internal_refs_size(); } inline void GroupingFunc::clear_refs() { _impl_.refs_.Clear(); } inline ::pg_query::Node* GroupingFunc::mutable_refs(int index) { // @@protoc_insertion_point(field_mutable:pg_query.GroupingFunc.refs) return _impl_.refs_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* GroupingFunc::mutable_refs() { // @@protoc_insertion_point(field_mutable_list:pg_query.GroupingFunc.refs) return &_impl_.refs_; } inline const ::pg_query::Node& GroupingFunc::_internal_refs(int index) const { return _impl_.refs_.Get(index); } inline const ::pg_query::Node& GroupingFunc::refs(int index) const { // @@protoc_insertion_point(field_get:pg_query.GroupingFunc.refs) return _internal_refs(index); } inline ::pg_query::Node* GroupingFunc::_internal_add_refs() { return _impl_.refs_.Add(); } inline ::pg_query::Node* GroupingFunc::add_refs() { ::pg_query::Node* _add = _internal_add_refs(); // @@protoc_insertion_point(field_add:pg_query.GroupingFunc.refs) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& GroupingFunc::refs() const { // @@protoc_insertion_point(field_list:pg_query.GroupingFunc.refs) return _impl_.refs_; } // repeated .pg_query.Node cols = 4 [json_name = "cols"]; inline int GroupingFunc::_internal_cols_size() const { return _impl_.cols_.size(); } inline int GroupingFunc::cols_size() const { return _internal_cols_size(); } inline void GroupingFunc::clear_cols() { _impl_.cols_.Clear(); } inline ::pg_query::Node* GroupingFunc::mutable_cols(int index) { // @@protoc_insertion_point(field_mutable:pg_query.GroupingFunc.cols) return _impl_.cols_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* GroupingFunc::mutable_cols() { // @@protoc_insertion_point(field_mutable_list:pg_query.GroupingFunc.cols) return &_impl_.cols_; } inline const ::pg_query::Node& GroupingFunc::_internal_cols(int index) const { return _impl_.cols_.Get(index); } inline const ::pg_query::Node& GroupingFunc::cols(int index) const { // @@protoc_insertion_point(field_get:pg_query.GroupingFunc.cols) return _internal_cols(index); } inline ::pg_query::Node* GroupingFunc::_internal_add_cols() { return _impl_.cols_.Add(); } inline ::pg_query::Node* GroupingFunc::add_cols() { ::pg_query::Node* _add = _internal_add_cols(); // @@protoc_insertion_point(field_add:pg_query.GroupingFunc.cols) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& GroupingFunc::cols() const { // @@protoc_insertion_point(field_list:pg_query.GroupingFunc.cols) return _impl_.cols_; } // uint32 agglevelsup = 5 [json_name = "agglevelsup"]; inline void GroupingFunc::clear_agglevelsup() { _impl_.agglevelsup_ = 0u; } inline uint32_t GroupingFunc::_internal_agglevelsup() const { return _impl_.agglevelsup_; } inline uint32_t GroupingFunc::agglevelsup() const { // @@protoc_insertion_point(field_get:pg_query.GroupingFunc.agglevelsup) return _internal_agglevelsup(); } inline void GroupingFunc::_internal_set_agglevelsup(uint32_t value) { _impl_.agglevelsup_ = value; } inline void GroupingFunc::set_agglevelsup(uint32_t value) { _internal_set_agglevelsup(value); // @@protoc_insertion_point(field_set:pg_query.GroupingFunc.agglevelsup) } // int32 location = 6 [json_name = "location"]; inline void GroupingFunc::clear_location() { _impl_.location_ = 0; } inline int32_t GroupingFunc::_internal_location() const { return _impl_.location_; } inline int32_t GroupingFunc::location() const { // @@protoc_insertion_point(field_get:pg_query.GroupingFunc.location) return _internal_location(); } inline void GroupingFunc::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void GroupingFunc::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.GroupingFunc.location) } // ------------------------------------------------------------------- // WindowFunc // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool WindowFunc::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool WindowFunc::has_xpr() const { return _internal_has_xpr(); } inline void WindowFunc::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& WindowFunc::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& WindowFunc::xpr() const { // @@protoc_insertion_point(field_get:pg_query.WindowFunc.xpr) return _internal_xpr(); } inline void WindowFunc::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.WindowFunc.xpr) } inline ::pg_query::Node* WindowFunc::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* WindowFunc::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.WindowFunc.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* WindowFunc::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* WindowFunc::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.WindowFunc.xpr) } // uint32 winfnoid = 2 [json_name = "winfnoid"]; inline void WindowFunc::clear_winfnoid() { _impl_.winfnoid_ = 0u; } inline uint32_t WindowFunc::_internal_winfnoid() const { return _impl_.winfnoid_; } inline uint32_t WindowFunc::winfnoid() const { // @@protoc_insertion_point(field_get:pg_query.WindowFunc.winfnoid) return _internal_winfnoid(); } inline void WindowFunc::_internal_set_winfnoid(uint32_t value) { _impl_.winfnoid_ = value; } inline void WindowFunc::set_winfnoid(uint32_t value) { _internal_set_winfnoid(value); // @@protoc_insertion_point(field_set:pg_query.WindowFunc.winfnoid) } // uint32 wintype = 3 [json_name = "wintype"]; inline void WindowFunc::clear_wintype() { _impl_.wintype_ = 0u; } inline uint32_t WindowFunc::_internal_wintype() const { return _impl_.wintype_; } inline uint32_t WindowFunc::wintype() const { // @@protoc_insertion_point(field_get:pg_query.WindowFunc.wintype) return _internal_wintype(); } inline void WindowFunc::_internal_set_wintype(uint32_t value) { _impl_.wintype_ = value; } inline void WindowFunc::set_wintype(uint32_t value) { _internal_set_wintype(value); // @@protoc_insertion_point(field_set:pg_query.WindowFunc.wintype) } // uint32 wincollid = 4 [json_name = "wincollid"]; inline void WindowFunc::clear_wincollid() { _impl_.wincollid_ = 0u; } inline uint32_t WindowFunc::_internal_wincollid() const { return _impl_.wincollid_; } inline uint32_t WindowFunc::wincollid() const { // @@protoc_insertion_point(field_get:pg_query.WindowFunc.wincollid) return _internal_wincollid(); } inline void WindowFunc::_internal_set_wincollid(uint32_t value) { _impl_.wincollid_ = value; } inline void WindowFunc::set_wincollid(uint32_t value) { _internal_set_wincollid(value); // @@protoc_insertion_point(field_set:pg_query.WindowFunc.wincollid) } // uint32 inputcollid = 5 [json_name = "inputcollid"]; inline void WindowFunc::clear_inputcollid() { _impl_.inputcollid_ = 0u; } inline uint32_t WindowFunc::_internal_inputcollid() const { return _impl_.inputcollid_; } inline uint32_t WindowFunc::inputcollid() const { // @@protoc_insertion_point(field_get:pg_query.WindowFunc.inputcollid) return _internal_inputcollid(); } inline void WindowFunc::_internal_set_inputcollid(uint32_t value) { _impl_.inputcollid_ = value; } inline void WindowFunc::set_inputcollid(uint32_t value) { _internal_set_inputcollid(value); // @@protoc_insertion_point(field_set:pg_query.WindowFunc.inputcollid) } // repeated .pg_query.Node args = 6 [json_name = "args"]; inline int WindowFunc::_internal_args_size() const { return _impl_.args_.size(); } inline int WindowFunc::args_size() const { return _internal_args_size(); } inline void WindowFunc::clear_args() { _impl_.args_.Clear(); } inline ::pg_query::Node* WindowFunc::mutable_args(int index) { // @@protoc_insertion_point(field_mutable:pg_query.WindowFunc.args) return _impl_.args_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* WindowFunc::mutable_args() { // @@protoc_insertion_point(field_mutable_list:pg_query.WindowFunc.args) return &_impl_.args_; } inline const ::pg_query::Node& WindowFunc::_internal_args(int index) const { return _impl_.args_.Get(index); } inline const ::pg_query::Node& WindowFunc::args(int index) const { // @@protoc_insertion_point(field_get:pg_query.WindowFunc.args) return _internal_args(index); } inline ::pg_query::Node* WindowFunc::_internal_add_args() { return _impl_.args_.Add(); } inline ::pg_query::Node* WindowFunc::add_args() { ::pg_query::Node* _add = _internal_add_args(); // @@protoc_insertion_point(field_add:pg_query.WindowFunc.args) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& WindowFunc::args() const { // @@protoc_insertion_point(field_list:pg_query.WindowFunc.args) return _impl_.args_; } // .pg_query.Node aggfilter = 7 [json_name = "aggfilter"]; inline bool WindowFunc::_internal_has_aggfilter() const { return this != internal_default_instance() && _impl_.aggfilter_ != nullptr; } inline bool WindowFunc::has_aggfilter() const { return _internal_has_aggfilter(); } inline void WindowFunc::clear_aggfilter() { if (GetArenaForAllocation() == nullptr && _impl_.aggfilter_ != nullptr) { delete _impl_.aggfilter_; } _impl_.aggfilter_ = nullptr; } inline const ::pg_query::Node& WindowFunc::_internal_aggfilter() const { const ::pg_query::Node* p = _impl_.aggfilter_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& WindowFunc::aggfilter() const { // @@protoc_insertion_point(field_get:pg_query.WindowFunc.aggfilter) return _internal_aggfilter(); } inline void WindowFunc::unsafe_arena_set_allocated_aggfilter( ::pg_query::Node* aggfilter) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.aggfilter_); } _impl_.aggfilter_ = aggfilter; if (aggfilter) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.WindowFunc.aggfilter) } inline ::pg_query::Node* WindowFunc::release_aggfilter() { ::pg_query::Node* temp = _impl_.aggfilter_; _impl_.aggfilter_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* WindowFunc::unsafe_arena_release_aggfilter() { // @@protoc_insertion_point(field_release:pg_query.WindowFunc.aggfilter) ::pg_query::Node* temp = _impl_.aggfilter_; _impl_.aggfilter_ = nullptr; return temp; } inline ::pg_query::Node* WindowFunc::_internal_mutable_aggfilter() { if (_impl_.aggfilter_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.aggfilter_ = p; } return _impl_.aggfilter_; } inline ::pg_query::Node* WindowFunc::mutable_aggfilter() { ::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* aggfilter) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.aggfilter_; } if (aggfilter) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(aggfilter); if (message_arena != submessage_arena) { aggfilter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, aggfilter, submessage_arena); } } else { } _impl_.aggfilter_ = aggfilter; // @@protoc_insertion_point(field_set_allocated:pg_query.WindowFunc.aggfilter) } // uint32 winref = 8 [json_name = "winref"]; inline void WindowFunc::clear_winref() { _impl_.winref_ = 0u; } inline uint32_t WindowFunc::_internal_winref() const { return _impl_.winref_; } inline uint32_t WindowFunc::winref() const { // @@protoc_insertion_point(field_get:pg_query.WindowFunc.winref) return _internal_winref(); } inline void WindowFunc::_internal_set_winref(uint32_t value) { _impl_.winref_ = value; } inline void WindowFunc::set_winref(uint32_t value) { _internal_set_winref(value); // @@protoc_insertion_point(field_set:pg_query.WindowFunc.winref) } // bool winstar = 9 [json_name = "winstar"]; inline void WindowFunc::clear_winstar() { _impl_.winstar_ = false; } inline bool WindowFunc::_internal_winstar() const { return _impl_.winstar_; } inline bool WindowFunc::winstar() const { // @@protoc_insertion_point(field_get:pg_query.WindowFunc.winstar) return _internal_winstar(); } inline void WindowFunc::_internal_set_winstar(bool value) { _impl_.winstar_ = value; } inline void WindowFunc::set_winstar(bool value) { _internal_set_winstar(value); // @@protoc_insertion_point(field_set:pg_query.WindowFunc.winstar) } // bool winagg = 10 [json_name = "winagg"]; inline void WindowFunc::clear_winagg() { _impl_.winagg_ = false; } inline bool WindowFunc::_internal_winagg() const { return _impl_.winagg_; } inline bool WindowFunc::winagg() const { // @@protoc_insertion_point(field_get:pg_query.WindowFunc.winagg) return _internal_winagg(); } inline void WindowFunc::_internal_set_winagg(bool value) { _impl_.winagg_ = value; } inline void WindowFunc::set_winagg(bool value) { _internal_set_winagg(value); // @@protoc_insertion_point(field_set:pg_query.WindowFunc.winagg) } // int32 location = 11 [json_name = "location"]; inline void WindowFunc::clear_location() { _impl_.location_ = 0; } inline int32_t WindowFunc::_internal_location() const { return _impl_.location_; } inline int32_t WindowFunc::location() const { // @@protoc_insertion_point(field_get:pg_query.WindowFunc.location) return _internal_location(); } inline void WindowFunc::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void WindowFunc::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.WindowFunc.location) } // ------------------------------------------------------------------- // SubscriptingRef // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool SubscriptingRef::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool SubscriptingRef::has_xpr() const { return _internal_has_xpr(); } inline void SubscriptingRef::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& SubscriptingRef::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& SubscriptingRef::xpr() const { // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.xpr) return _internal_xpr(); } inline void SubscriptingRef::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SubscriptingRef.xpr) } inline ::pg_query::Node* SubscriptingRef::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* SubscriptingRef::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.SubscriptingRef.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* SubscriptingRef::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* SubscriptingRef::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.SubscriptingRef.xpr) } // uint32 refcontainertype = 2 [json_name = "refcontainertype"]; inline void SubscriptingRef::clear_refcontainertype() { _impl_.refcontainertype_ = 0u; } inline uint32_t SubscriptingRef::_internal_refcontainertype() const { return _impl_.refcontainertype_; } inline uint32_t SubscriptingRef::refcontainertype() const { // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.refcontainertype) return _internal_refcontainertype(); } inline void SubscriptingRef::_internal_set_refcontainertype(uint32_t value) { _impl_.refcontainertype_ = value; } inline void SubscriptingRef::set_refcontainertype(uint32_t value) { _internal_set_refcontainertype(value); // @@protoc_insertion_point(field_set:pg_query.SubscriptingRef.refcontainertype) } // uint32 refelemtype = 3 [json_name = "refelemtype"]; inline void SubscriptingRef::clear_refelemtype() { _impl_.refelemtype_ = 0u; } inline uint32_t SubscriptingRef::_internal_refelemtype() const { return _impl_.refelemtype_; } inline uint32_t SubscriptingRef::refelemtype() const { // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.refelemtype) return _internal_refelemtype(); } inline void SubscriptingRef::_internal_set_refelemtype(uint32_t value) { _impl_.refelemtype_ = value; } inline void SubscriptingRef::set_refelemtype(uint32_t value) { _internal_set_refelemtype(value); // @@protoc_insertion_point(field_set:pg_query.SubscriptingRef.refelemtype) } // uint32 refrestype = 4 [json_name = "refrestype"]; inline void SubscriptingRef::clear_refrestype() { _impl_.refrestype_ = 0u; } inline uint32_t SubscriptingRef::_internal_refrestype() const { return _impl_.refrestype_; } inline uint32_t SubscriptingRef::refrestype() const { // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.refrestype) return _internal_refrestype(); } inline void SubscriptingRef::_internal_set_refrestype(uint32_t value) { _impl_.refrestype_ = value; } inline void SubscriptingRef::set_refrestype(uint32_t value) { _internal_set_refrestype(value); // @@protoc_insertion_point(field_set:pg_query.SubscriptingRef.refrestype) } // int32 reftypmod = 5 [json_name = "reftypmod"]; inline void SubscriptingRef::clear_reftypmod() { _impl_.reftypmod_ = 0; } inline int32_t SubscriptingRef::_internal_reftypmod() const { return _impl_.reftypmod_; } inline int32_t SubscriptingRef::reftypmod() const { // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.reftypmod) return _internal_reftypmod(); } inline void SubscriptingRef::_internal_set_reftypmod(int32_t value) { _impl_.reftypmod_ = value; } inline void SubscriptingRef::set_reftypmod(int32_t value) { _internal_set_reftypmod(value); // @@protoc_insertion_point(field_set:pg_query.SubscriptingRef.reftypmod) } // uint32 refcollid = 6 [json_name = "refcollid"]; inline void SubscriptingRef::clear_refcollid() { _impl_.refcollid_ = 0u; } inline uint32_t SubscriptingRef::_internal_refcollid() const { return _impl_.refcollid_; } inline uint32_t SubscriptingRef::refcollid() const { // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.refcollid) return _internal_refcollid(); } inline void SubscriptingRef::_internal_set_refcollid(uint32_t value) { _impl_.refcollid_ = value; } inline void SubscriptingRef::set_refcollid(uint32_t value) { _internal_set_refcollid(value); // @@protoc_insertion_point(field_set:pg_query.SubscriptingRef.refcollid) } // repeated .pg_query.Node refupperindexpr = 7 [json_name = "refupperindexpr"]; inline int SubscriptingRef::_internal_refupperindexpr_size() const { return _impl_.refupperindexpr_.size(); } inline int SubscriptingRef::refupperindexpr_size() const { return _internal_refupperindexpr_size(); } inline void SubscriptingRef::clear_refupperindexpr() { _impl_.refupperindexpr_.Clear(); } inline ::pg_query::Node* SubscriptingRef::mutable_refupperindexpr(int index) { // @@protoc_insertion_point(field_mutable:pg_query.SubscriptingRef.refupperindexpr) return _impl_.refupperindexpr_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* SubscriptingRef::mutable_refupperindexpr() { // @@protoc_insertion_point(field_mutable_list:pg_query.SubscriptingRef.refupperindexpr) return &_impl_.refupperindexpr_; } inline const ::pg_query::Node& SubscriptingRef::_internal_refupperindexpr(int index) const { return _impl_.refupperindexpr_.Get(index); } inline const ::pg_query::Node& SubscriptingRef::refupperindexpr(int index) const { // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.refupperindexpr) return _internal_refupperindexpr(index); } inline ::pg_query::Node* SubscriptingRef::_internal_add_refupperindexpr() { return _impl_.refupperindexpr_.Add(); } inline ::pg_query::Node* SubscriptingRef::add_refupperindexpr() { ::pg_query::Node* _add = _internal_add_refupperindexpr(); // @@protoc_insertion_point(field_add:pg_query.SubscriptingRef.refupperindexpr) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& SubscriptingRef::refupperindexpr() const { // @@protoc_insertion_point(field_list:pg_query.SubscriptingRef.refupperindexpr) return _impl_.refupperindexpr_; } // repeated .pg_query.Node reflowerindexpr = 8 [json_name = "reflowerindexpr"]; inline int SubscriptingRef::_internal_reflowerindexpr_size() const { return _impl_.reflowerindexpr_.size(); } inline int SubscriptingRef::reflowerindexpr_size() const { return _internal_reflowerindexpr_size(); } inline void SubscriptingRef::clear_reflowerindexpr() { _impl_.reflowerindexpr_.Clear(); } inline ::pg_query::Node* SubscriptingRef::mutable_reflowerindexpr(int index) { // @@protoc_insertion_point(field_mutable:pg_query.SubscriptingRef.reflowerindexpr) return _impl_.reflowerindexpr_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* SubscriptingRef::mutable_reflowerindexpr() { // @@protoc_insertion_point(field_mutable_list:pg_query.SubscriptingRef.reflowerindexpr) return &_impl_.reflowerindexpr_; } inline const ::pg_query::Node& SubscriptingRef::_internal_reflowerindexpr(int index) const { return _impl_.reflowerindexpr_.Get(index); } inline const ::pg_query::Node& SubscriptingRef::reflowerindexpr(int index) const { // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.reflowerindexpr) return _internal_reflowerindexpr(index); } inline ::pg_query::Node* SubscriptingRef::_internal_add_reflowerindexpr() { return _impl_.reflowerindexpr_.Add(); } inline ::pg_query::Node* SubscriptingRef::add_reflowerindexpr() { ::pg_query::Node* _add = _internal_add_reflowerindexpr(); // @@protoc_insertion_point(field_add:pg_query.SubscriptingRef.reflowerindexpr) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& SubscriptingRef::reflowerindexpr() const { // @@protoc_insertion_point(field_list:pg_query.SubscriptingRef.reflowerindexpr) return _impl_.reflowerindexpr_; } // .pg_query.Node refexpr = 9 [json_name = "refexpr"]; inline bool SubscriptingRef::_internal_has_refexpr() const { return this != internal_default_instance() && _impl_.refexpr_ != nullptr; } inline bool SubscriptingRef::has_refexpr() const { return _internal_has_refexpr(); } inline void SubscriptingRef::clear_refexpr() { if (GetArenaForAllocation() == nullptr && _impl_.refexpr_ != nullptr) { delete _impl_.refexpr_; } _impl_.refexpr_ = nullptr; } inline const ::pg_query::Node& SubscriptingRef::_internal_refexpr() const { const ::pg_query::Node* p = _impl_.refexpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& SubscriptingRef::refexpr() const { // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.refexpr) return _internal_refexpr(); } inline void SubscriptingRef::unsafe_arena_set_allocated_refexpr( ::pg_query::Node* refexpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.refexpr_); } _impl_.refexpr_ = refexpr; if (refexpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SubscriptingRef.refexpr) } inline ::pg_query::Node* SubscriptingRef::release_refexpr() { ::pg_query::Node* temp = _impl_.refexpr_; _impl_.refexpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* SubscriptingRef::unsafe_arena_release_refexpr() { // @@protoc_insertion_point(field_release:pg_query.SubscriptingRef.refexpr) ::pg_query::Node* temp = _impl_.refexpr_; _impl_.refexpr_ = nullptr; return temp; } inline ::pg_query::Node* SubscriptingRef::_internal_mutable_refexpr() { if (_impl_.refexpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.refexpr_ = p; } return _impl_.refexpr_; } inline ::pg_query::Node* SubscriptingRef::mutable_refexpr() { ::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* refexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.refexpr_; } if (refexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(refexpr); if (message_arena != submessage_arena) { refexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, refexpr, submessage_arena); } } else { } _impl_.refexpr_ = refexpr; // @@protoc_insertion_point(field_set_allocated:pg_query.SubscriptingRef.refexpr) } // .pg_query.Node refassgnexpr = 10 [json_name = "refassgnexpr"]; inline bool SubscriptingRef::_internal_has_refassgnexpr() const { return this != internal_default_instance() && _impl_.refassgnexpr_ != nullptr; } inline bool SubscriptingRef::has_refassgnexpr() const { return _internal_has_refassgnexpr(); } inline void SubscriptingRef::clear_refassgnexpr() { if (GetArenaForAllocation() == nullptr && _impl_.refassgnexpr_ != nullptr) { delete _impl_.refassgnexpr_; } _impl_.refassgnexpr_ = nullptr; } inline const ::pg_query::Node& SubscriptingRef::_internal_refassgnexpr() const { const ::pg_query::Node* p = _impl_.refassgnexpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& SubscriptingRef::refassgnexpr() const { // @@protoc_insertion_point(field_get:pg_query.SubscriptingRef.refassgnexpr) return _internal_refassgnexpr(); } inline void SubscriptingRef::unsafe_arena_set_allocated_refassgnexpr( ::pg_query::Node* refassgnexpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.refassgnexpr_); } _impl_.refassgnexpr_ = refassgnexpr; if (refassgnexpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SubscriptingRef.refassgnexpr) } inline ::pg_query::Node* SubscriptingRef::release_refassgnexpr() { ::pg_query::Node* temp = _impl_.refassgnexpr_; _impl_.refassgnexpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* SubscriptingRef::unsafe_arena_release_refassgnexpr() { // @@protoc_insertion_point(field_release:pg_query.SubscriptingRef.refassgnexpr) ::pg_query::Node* temp = _impl_.refassgnexpr_; _impl_.refassgnexpr_ = nullptr; return temp; } inline ::pg_query::Node* SubscriptingRef::_internal_mutable_refassgnexpr() { if (_impl_.refassgnexpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.refassgnexpr_ = p; } return _impl_.refassgnexpr_; } inline ::pg_query::Node* SubscriptingRef::mutable_refassgnexpr() { ::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* refassgnexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.refassgnexpr_; } if (refassgnexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(refassgnexpr); if (message_arena != submessage_arena) { refassgnexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, refassgnexpr, submessage_arena); } } else { } _impl_.refassgnexpr_ = refassgnexpr; // @@protoc_insertion_point(field_set_allocated:pg_query.SubscriptingRef.refassgnexpr) } // ------------------------------------------------------------------- // FuncExpr // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool FuncExpr::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool FuncExpr::has_xpr() const { return _internal_has_xpr(); } inline void FuncExpr::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& FuncExpr::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& FuncExpr::xpr() const { // @@protoc_insertion_point(field_get:pg_query.FuncExpr.xpr) return _internal_xpr(); } inline void FuncExpr::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FuncExpr.xpr) } inline ::pg_query::Node* FuncExpr::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* FuncExpr::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.FuncExpr.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* FuncExpr::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* FuncExpr::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.FuncExpr.xpr) } // uint32 funcid = 2 [json_name = "funcid"]; inline void FuncExpr::clear_funcid() { _impl_.funcid_ = 0u; } inline uint32_t FuncExpr::_internal_funcid() const { return _impl_.funcid_; } inline uint32_t FuncExpr::funcid() const { // @@protoc_insertion_point(field_get:pg_query.FuncExpr.funcid) return _internal_funcid(); } inline void FuncExpr::_internal_set_funcid(uint32_t value) { _impl_.funcid_ = value; } inline void FuncExpr::set_funcid(uint32_t value) { _internal_set_funcid(value); // @@protoc_insertion_point(field_set:pg_query.FuncExpr.funcid) } // uint32 funcresulttype = 3 [json_name = "funcresulttype"]; inline void FuncExpr::clear_funcresulttype() { _impl_.funcresulttype_ = 0u; } inline uint32_t FuncExpr::_internal_funcresulttype() const { return _impl_.funcresulttype_; } inline uint32_t FuncExpr::funcresulttype() const { // @@protoc_insertion_point(field_get:pg_query.FuncExpr.funcresulttype) return _internal_funcresulttype(); } inline void FuncExpr::_internal_set_funcresulttype(uint32_t value) { _impl_.funcresulttype_ = value; } inline void FuncExpr::set_funcresulttype(uint32_t value) { _internal_set_funcresulttype(value); // @@protoc_insertion_point(field_set:pg_query.FuncExpr.funcresulttype) } // bool funcretset = 4 [json_name = "funcretset"]; inline void FuncExpr::clear_funcretset() { _impl_.funcretset_ = false; } inline bool FuncExpr::_internal_funcretset() const { return _impl_.funcretset_; } inline bool FuncExpr::funcretset() const { // @@protoc_insertion_point(field_get:pg_query.FuncExpr.funcretset) return _internal_funcretset(); } inline void FuncExpr::_internal_set_funcretset(bool value) { _impl_.funcretset_ = value; } inline void FuncExpr::set_funcretset(bool value) { _internal_set_funcretset(value); // @@protoc_insertion_point(field_set:pg_query.FuncExpr.funcretset) } // bool funcvariadic = 5 [json_name = "funcvariadic"]; inline void FuncExpr::clear_funcvariadic() { _impl_.funcvariadic_ = false; } inline bool FuncExpr::_internal_funcvariadic() const { return _impl_.funcvariadic_; } inline bool FuncExpr::funcvariadic() const { // @@protoc_insertion_point(field_get:pg_query.FuncExpr.funcvariadic) return _internal_funcvariadic(); } inline void FuncExpr::_internal_set_funcvariadic(bool value) { _impl_.funcvariadic_ = value; } inline void FuncExpr::set_funcvariadic(bool value) { _internal_set_funcvariadic(value); // @@protoc_insertion_point(field_set:pg_query.FuncExpr.funcvariadic) } // .pg_query.CoercionForm funcformat = 6 [json_name = "funcformat"]; inline void FuncExpr::clear_funcformat() { _impl_.funcformat_ = 0; } inline ::pg_query::CoercionForm FuncExpr::_internal_funcformat() const { return static_cast< ::pg_query::CoercionForm >(_impl_.funcformat_); } inline ::pg_query::CoercionForm FuncExpr::funcformat() const { // @@protoc_insertion_point(field_get:pg_query.FuncExpr.funcformat) return _internal_funcformat(); } inline void FuncExpr::_internal_set_funcformat(::pg_query::CoercionForm value) { _impl_.funcformat_ = value; } inline void FuncExpr::set_funcformat(::pg_query::CoercionForm value) { _internal_set_funcformat(value); // @@protoc_insertion_point(field_set:pg_query.FuncExpr.funcformat) } // uint32 funccollid = 7 [json_name = "funccollid"]; inline void FuncExpr::clear_funccollid() { _impl_.funccollid_ = 0u; } inline uint32_t FuncExpr::_internal_funccollid() const { return _impl_.funccollid_; } inline uint32_t FuncExpr::funccollid() const { // @@protoc_insertion_point(field_get:pg_query.FuncExpr.funccollid) return _internal_funccollid(); } inline void FuncExpr::_internal_set_funccollid(uint32_t value) { _impl_.funccollid_ = value; } inline void FuncExpr::set_funccollid(uint32_t value) { _internal_set_funccollid(value); // @@protoc_insertion_point(field_set:pg_query.FuncExpr.funccollid) } // uint32 inputcollid = 8 [json_name = "inputcollid"]; inline void FuncExpr::clear_inputcollid() { _impl_.inputcollid_ = 0u; } inline uint32_t FuncExpr::_internal_inputcollid() const { return _impl_.inputcollid_; } inline uint32_t FuncExpr::inputcollid() const { // @@protoc_insertion_point(field_get:pg_query.FuncExpr.inputcollid) return _internal_inputcollid(); } inline void FuncExpr::_internal_set_inputcollid(uint32_t value) { _impl_.inputcollid_ = value; } inline void FuncExpr::set_inputcollid(uint32_t value) { _internal_set_inputcollid(value); // @@protoc_insertion_point(field_set:pg_query.FuncExpr.inputcollid) } // repeated .pg_query.Node args = 9 [json_name = "args"]; inline int FuncExpr::_internal_args_size() const { return _impl_.args_.size(); } inline int FuncExpr::args_size() const { return _internal_args_size(); } inline void FuncExpr::clear_args() { _impl_.args_.Clear(); } inline ::pg_query::Node* FuncExpr::mutable_args(int index) { // @@protoc_insertion_point(field_mutable:pg_query.FuncExpr.args) return _impl_.args_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* FuncExpr::mutable_args() { // @@protoc_insertion_point(field_mutable_list:pg_query.FuncExpr.args) return &_impl_.args_; } inline const ::pg_query::Node& FuncExpr::_internal_args(int index) const { return _impl_.args_.Get(index); } inline const ::pg_query::Node& FuncExpr::args(int index) const { // @@protoc_insertion_point(field_get:pg_query.FuncExpr.args) return _internal_args(index); } inline ::pg_query::Node* FuncExpr::_internal_add_args() { return _impl_.args_.Add(); } inline ::pg_query::Node* FuncExpr::add_args() { ::pg_query::Node* _add = _internal_add_args(); // @@protoc_insertion_point(field_add:pg_query.FuncExpr.args) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& FuncExpr::args() const { // @@protoc_insertion_point(field_list:pg_query.FuncExpr.args) return _impl_.args_; } // int32 location = 10 [json_name = "location"]; inline void FuncExpr::clear_location() { _impl_.location_ = 0; } inline int32_t FuncExpr::_internal_location() const { return _impl_.location_; } inline int32_t FuncExpr::location() const { // @@protoc_insertion_point(field_get:pg_query.FuncExpr.location) return _internal_location(); } inline void FuncExpr::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void FuncExpr::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.FuncExpr.location) } // ------------------------------------------------------------------- // NamedArgExpr // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool NamedArgExpr::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool NamedArgExpr::has_xpr() const { return _internal_has_xpr(); } inline void NamedArgExpr::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& NamedArgExpr::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& NamedArgExpr::xpr() const { // @@protoc_insertion_point(field_get:pg_query.NamedArgExpr.xpr) return _internal_xpr(); } inline void NamedArgExpr::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.NamedArgExpr.xpr) } inline ::pg_query::Node* NamedArgExpr::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* NamedArgExpr::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.NamedArgExpr.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* NamedArgExpr::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* NamedArgExpr::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.NamedArgExpr.xpr) } // .pg_query.Node arg = 2 [json_name = "arg"]; inline bool NamedArgExpr::_internal_has_arg() const { return this != internal_default_instance() && _impl_.arg_ != nullptr; } inline bool NamedArgExpr::has_arg() const { return _internal_has_arg(); } inline void NamedArgExpr::clear_arg() { if (GetArenaForAllocation() == nullptr && _impl_.arg_ != nullptr) { delete _impl_.arg_; } _impl_.arg_ = nullptr; } inline const ::pg_query::Node& NamedArgExpr::_internal_arg() const { const ::pg_query::Node* p = _impl_.arg_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& NamedArgExpr::arg() const { // @@protoc_insertion_point(field_get:pg_query.NamedArgExpr.arg) return _internal_arg(); } inline void NamedArgExpr::unsafe_arena_set_allocated_arg( ::pg_query::Node* arg) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.arg_); } _impl_.arg_ = arg; if (arg) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.NamedArgExpr.arg) } inline ::pg_query::Node* NamedArgExpr::release_arg() { ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* NamedArgExpr::unsafe_arena_release_arg() { // @@protoc_insertion_point(field_release:pg_query.NamedArgExpr.arg) ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; return temp; } inline ::pg_query::Node* NamedArgExpr::_internal_mutable_arg() { if (_impl_.arg_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.arg_ = p; } return _impl_.arg_; } inline ::pg_query::Node* NamedArgExpr::mutable_arg() { ::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* arg) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.arg_; } if (arg) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(arg); if (message_arena != submessage_arena) { arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, arg, submessage_arena); } } else { } _impl_.arg_ = arg; // @@protoc_insertion_point(field_set_allocated:pg_query.NamedArgExpr.arg) } // string name = 3 [json_name = "name"]; inline void NamedArgExpr::clear_name() { _impl_.name_.ClearToEmpty(); } inline const std::string& NamedArgExpr::name() const { // @@protoc_insertion_point(field_get:pg_query.NamedArgExpr.name) return _internal_name(); } template inline PROTOBUF_ALWAYS_INLINE void NamedArgExpr::set_name(ArgT0&& arg0, ArgT... args) { _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.NamedArgExpr.name) } inline std::string* NamedArgExpr::mutable_name() { 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 { return _impl_.name_.Get(); } inline void NamedArgExpr::_internal_set_name(const std::string& value) { _impl_.name_.Set(value, GetArenaForAllocation()); } inline std::string* NamedArgExpr::_internal_mutable_name() { return _impl_.name_.Mutable(GetArenaForAllocation()); } inline std::string* NamedArgExpr::release_name() { // @@protoc_insertion_point(field_release:pg_query.NamedArgExpr.name) return _impl_.name_.Release(); } inline void NamedArgExpr::set_allocated_name(std::string* name) { if (name != nullptr) { } else { } _impl_.name_.SetAllocated(name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.name_.IsDefault()) { _impl_.name_.Set("", GetArenaForAllocation()); } #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() { _impl_.argnumber_ = 0; } inline int32_t NamedArgExpr::_internal_argnumber() const { return _impl_.argnumber_; } inline int32_t NamedArgExpr::argnumber() const { // @@protoc_insertion_point(field_get:pg_query.NamedArgExpr.argnumber) return _internal_argnumber(); } inline void NamedArgExpr::_internal_set_argnumber(int32_t value) { _impl_.argnumber_ = value; } inline void NamedArgExpr::set_argnumber(int32_t value) { _internal_set_argnumber(value); // @@protoc_insertion_point(field_set:pg_query.NamedArgExpr.argnumber) } // int32 location = 5 [json_name = "location"]; inline void NamedArgExpr::clear_location() { _impl_.location_ = 0; } inline int32_t NamedArgExpr::_internal_location() const { return _impl_.location_; } inline int32_t NamedArgExpr::location() const { // @@protoc_insertion_point(field_get:pg_query.NamedArgExpr.location) return _internal_location(); } inline void NamedArgExpr::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void NamedArgExpr::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.NamedArgExpr.location) } // ------------------------------------------------------------------- // OpExpr // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool OpExpr::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool OpExpr::has_xpr() const { return _internal_has_xpr(); } inline void OpExpr::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& OpExpr::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& OpExpr::xpr() const { // @@protoc_insertion_point(field_get:pg_query.OpExpr.xpr) return _internal_xpr(); } inline void OpExpr::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.OpExpr.xpr) } inline ::pg_query::Node* OpExpr::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* OpExpr::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.OpExpr.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* OpExpr::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* OpExpr::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.OpExpr.xpr) } // uint32 opno = 2 [json_name = "opno"]; inline void OpExpr::clear_opno() { _impl_.opno_ = 0u; } inline uint32_t OpExpr::_internal_opno() const { return _impl_.opno_; } inline uint32_t OpExpr::opno() const { // @@protoc_insertion_point(field_get:pg_query.OpExpr.opno) return _internal_opno(); } inline void OpExpr::_internal_set_opno(uint32_t value) { _impl_.opno_ = value; } inline void OpExpr::set_opno(uint32_t value) { _internal_set_opno(value); // @@protoc_insertion_point(field_set:pg_query.OpExpr.opno) } // uint32 opfuncid = 3 [json_name = "opfuncid"]; inline void OpExpr::clear_opfuncid() { _impl_.opfuncid_ = 0u; } inline uint32_t OpExpr::_internal_opfuncid() const { return _impl_.opfuncid_; } inline uint32_t OpExpr::opfuncid() const { // @@protoc_insertion_point(field_get:pg_query.OpExpr.opfuncid) return _internal_opfuncid(); } inline void OpExpr::_internal_set_opfuncid(uint32_t value) { _impl_.opfuncid_ = value; } inline void OpExpr::set_opfuncid(uint32_t value) { _internal_set_opfuncid(value); // @@protoc_insertion_point(field_set:pg_query.OpExpr.opfuncid) } // uint32 opresulttype = 4 [json_name = "opresulttype"]; inline void OpExpr::clear_opresulttype() { _impl_.opresulttype_ = 0u; } inline uint32_t OpExpr::_internal_opresulttype() const { return _impl_.opresulttype_; } inline uint32_t OpExpr::opresulttype() const { // @@protoc_insertion_point(field_get:pg_query.OpExpr.opresulttype) return _internal_opresulttype(); } inline void OpExpr::_internal_set_opresulttype(uint32_t value) { _impl_.opresulttype_ = value; } inline void OpExpr::set_opresulttype(uint32_t value) { _internal_set_opresulttype(value); // @@protoc_insertion_point(field_set:pg_query.OpExpr.opresulttype) } // bool opretset = 5 [json_name = "opretset"]; inline void OpExpr::clear_opretset() { _impl_.opretset_ = false; } inline bool OpExpr::_internal_opretset() const { return _impl_.opretset_; } inline bool OpExpr::opretset() const { // @@protoc_insertion_point(field_get:pg_query.OpExpr.opretset) return _internal_opretset(); } inline void OpExpr::_internal_set_opretset(bool value) { _impl_.opretset_ = value; } inline void OpExpr::set_opretset(bool value) { _internal_set_opretset(value); // @@protoc_insertion_point(field_set:pg_query.OpExpr.opretset) } // uint32 opcollid = 6 [json_name = "opcollid"]; inline void OpExpr::clear_opcollid() { _impl_.opcollid_ = 0u; } inline uint32_t OpExpr::_internal_opcollid() const { return _impl_.opcollid_; } inline uint32_t OpExpr::opcollid() const { // @@protoc_insertion_point(field_get:pg_query.OpExpr.opcollid) return _internal_opcollid(); } inline void OpExpr::_internal_set_opcollid(uint32_t value) { _impl_.opcollid_ = value; } inline void OpExpr::set_opcollid(uint32_t value) { _internal_set_opcollid(value); // @@protoc_insertion_point(field_set:pg_query.OpExpr.opcollid) } // uint32 inputcollid = 7 [json_name = "inputcollid"]; inline void OpExpr::clear_inputcollid() { _impl_.inputcollid_ = 0u; } inline uint32_t OpExpr::_internal_inputcollid() const { return _impl_.inputcollid_; } inline uint32_t OpExpr::inputcollid() const { // @@protoc_insertion_point(field_get:pg_query.OpExpr.inputcollid) return _internal_inputcollid(); } inline void OpExpr::_internal_set_inputcollid(uint32_t value) { _impl_.inputcollid_ = value; } inline void OpExpr::set_inputcollid(uint32_t value) { _internal_set_inputcollid(value); // @@protoc_insertion_point(field_set:pg_query.OpExpr.inputcollid) } // repeated .pg_query.Node args = 8 [json_name = "args"]; inline int OpExpr::_internal_args_size() const { return _impl_.args_.size(); } inline int OpExpr::args_size() const { return _internal_args_size(); } inline void OpExpr::clear_args() { _impl_.args_.Clear(); } inline ::pg_query::Node* OpExpr::mutable_args(int index) { // @@protoc_insertion_point(field_mutable:pg_query.OpExpr.args) return _impl_.args_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* OpExpr::mutable_args() { // @@protoc_insertion_point(field_mutable_list:pg_query.OpExpr.args) return &_impl_.args_; } inline const ::pg_query::Node& OpExpr::_internal_args(int index) const { return _impl_.args_.Get(index); } inline const ::pg_query::Node& OpExpr::args(int index) const { // @@protoc_insertion_point(field_get:pg_query.OpExpr.args) return _internal_args(index); } inline ::pg_query::Node* OpExpr::_internal_add_args() { return _impl_.args_.Add(); } inline ::pg_query::Node* OpExpr::add_args() { ::pg_query::Node* _add = _internal_add_args(); // @@protoc_insertion_point(field_add:pg_query.OpExpr.args) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& OpExpr::args() const { // @@protoc_insertion_point(field_list:pg_query.OpExpr.args) return _impl_.args_; } // int32 location = 9 [json_name = "location"]; inline void OpExpr::clear_location() { _impl_.location_ = 0; } inline int32_t OpExpr::_internal_location() const { return _impl_.location_; } inline int32_t OpExpr::location() const { // @@protoc_insertion_point(field_get:pg_query.OpExpr.location) return _internal_location(); } inline void OpExpr::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void OpExpr::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.OpExpr.location) } // ------------------------------------------------------------------- // DistinctExpr // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool DistinctExpr::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool DistinctExpr::has_xpr() const { return _internal_has_xpr(); } inline void DistinctExpr::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& DistinctExpr::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& DistinctExpr::xpr() const { // @@protoc_insertion_point(field_get:pg_query.DistinctExpr.xpr) return _internal_xpr(); } inline void DistinctExpr::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.DistinctExpr.xpr) } inline ::pg_query::Node* DistinctExpr::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* DistinctExpr::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.DistinctExpr.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* DistinctExpr::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* DistinctExpr::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.DistinctExpr.xpr) } // uint32 opno = 2 [json_name = "opno"]; inline void DistinctExpr::clear_opno() { _impl_.opno_ = 0u; } inline uint32_t DistinctExpr::_internal_opno() const { return _impl_.opno_; } inline uint32_t DistinctExpr::opno() const { // @@protoc_insertion_point(field_get:pg_query.DistinctExpr.opno) return _internal_opno(); } inline void DistinctExpr::_internal_set_opno(uint32_t value) { _impl_.opno_ = value; } inline void DistinctExpr::set_opno(uint32_t value) { _internal_set_opno(value); // @@protoc_insertion_point(field_set:pg_query.DistinctExpr.opno) } // uint32 opfuncid = 3 [json_name = "opfuncid"]; inline void DistinctExpr::clear_opfuncid() { _impl_.opfuncid_ = 0u; } inline uint32_t DistinctExpr::_internal_opfuncid() const { return _impl_.opfuncid_; } inline uint32_t DistinctExpr::opfuncid() const { // @@protoc_insertion_point(field_get:pg_query.DistinctExpr.opfuncid) return _internal_opfuncid(); } inline void DistinctExpr::_internal_set_opfuncid(uint32_t value) { _impl_.opfuncid_ = value; } inline void DistinctExpr::set_opfuncid(uint32_t value) { _internal_set_opfuncid(value); // @@protoc_insertion_point(field_set:pg_query.DistinctExpr.opfuncid) } // uint32 opresulttype = 4 [json_name = "opresulttype"]; inline void DistinctExpr::clear_opresulttype() { _impl_.opresulttype_ = 0u; } inline uint32_t DistinctExpr::_internal_opresulttype() const { return _impl_.opresulttype_; } inline uint32_t DistinctExpr::opresulttype() const { // @@protoc_insertion_point(field_get:pg_query.DistinctExpr.opresulttype) return _internal_opresulttype(); } inline void DistinctExpr::_internal_set_opresulttype(uint32_t value) { _impl_.opresulttype_ = value; } inline void DistinctExpr::set_opresulttype(uint32_t value) { _internal_set_opresulttype(value); // @@protoc_insertion_point(field_set:pg_query.DistinctExpr.opresulttype) } // bool opretset = 5 [json_name = "opretset"]; inline void DistinctExpr::clear_opretset() { _impl_.opretset_ = false; } inline bool DistinctExpr::_internal_opretset() const { return _impl_.opretset_; } inline bool DistinctExpr::opretset() const { // @@protoc_insertion_point(field_get:pg_query.DistinctExpr.opretset) return _internal_opretset(); } inline void DistinctExpr::_internal_set_opretset(bool value) { _impl_.opretset_ = value; } inline void DistinctExpr::set_opretset(bool value) { _internal_set_opretset(value); // @@protoc_insertion_point(field_set:pg_query.DistinctExpr.opretset) } // uint32 opcollid = 6 [json_name = "opcollid"]; inline void DistinctExpr::clear_opcollid() { _impl_.opcollid_ = 0u; } inline uint32_t DistinctExpr::_internal_opcollid() const { return _impl_.opcollid_; } inline uint32_t DistinctExpr::opcollid() const { // @@protoc_insertion_point(field_get:pg_query.DistinctExpr.opcollid) return _internal_opcollid(); } inline void DistinctExpr::_internal_set_opcollid(uint32_t value) { _impl_.opcollid_ = value; } inline void DistinctExpr::set_opcollid(uint32_t value) { _internal_set_opcollid(value); // @@protoc_insertion_point(field_set:pg_query.DistinctExpr.opcollid) } // uint32 inputcollid = 7 [json_name = "inputcollid"]; inline void DistinctExpr::clear_inputcollid() { _impl_.inputcollid_ = 0u; } inline uint32_t DistinctExpr::_internal_inputcollid() const { return _impl_.inputcollid_; } inline uint32_t DistinctExpr::inputcollid() const { // @@protoc_insertion_point(field_get:pg_query.DistinctExpr.inputcollid) return _internal_inputcollid(); } inline void DistinctExpr::_internal_set_inputcollid(uint32_t value) { _impl_.inputcollid_ = value; } inline void DistinctExpr::set_inputcollid(uint32_t value) { _internal_set_inputcollid(value); // @@protoc_insertion_point(field_set:pg_query.DistinctExpr.inputcollid) } // repeated .pg_query.Node args = 8 [json_name = "args"]; inline int DistinctExpr::_internal_args_size() const { return _impl_.args_.size(); } inline int DistinctExpr::args_size() const { return _internal_args_size(); } inline void DistinctExpr::clear_args() { _impl_.args_.Clear(); } inline ::pg_query::Node* DistinctExpr::mutable_args(int index) { // @@protoc_insertion_point(field_mutable:pg_query.DistinctExpr.args) return _impl_.args_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* DistinctExpr::mutable_args() { // @@protoc_insertion_point(field_mutable_list:pg_query.DistinctExpr.args) return &_impl_.args_; } inline const ::pg_query::Node& DistinctExpr::_internal_args(int index) const { return _impl_.args_.Get(index); } inline const ::pg_query::Node& DistinctExpr::args(int index) const { // @@protoc_insertion_point(field_get:pg_query.DistinctExpr.args) return _internal_args(index); } inline ::pg_query::Node* DistinctExpr::_internal_add_args() { return _impl_.args_.Add(); } inline ::pg_query::Node* DistinctExpr::add_args() { ::pg_query::Node* _add = _internal_add_args(); // @@protoc_insertion_point(field_add:pg_query.DistinctExpr.args) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& DistinctExpr::args() const { // @@protoc_insertion_point(field_list:pg_query.DistinctExpr.args) return _impl_.args_; } // int32 location = 9 [json_name = "location"]; inline void DistinctExpr::clear_location() { _impl_.location_ = 0; } inline int32_t DistinctExpr::_internal_location() const { return _impl_.location_; } inline int32_t DistinctExpr::location() const { // @@protoc_insertion_point(field_get:pg_query.DistinctExpr.location) return _internal_location(); } inline void DistinctExpr::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void DistinctExpr::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.DistinctExpr.location) } // ------------------------------------------------------------------- // NullIfExpr // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool NullIfExpr::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool NullIfExpr::has_xpr() const { return _internal_has_xpr(); } inline void NullIfExpr::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& NullIfExpr::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& NullIfExpr::xpr() const { // @@protoc_insertion_point(field_get:pg_query.NullIfExpr.xpr) return _internal_xpr(); } inline void NullIfExpr::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.NullIfExpr.xpr) } inline ::pg_query::Node* NullIfExpr::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* NullIfExpr::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.NullIfExpr.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* NullIfExpr::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* NullIfExpr::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.NullIfExpr.xpr) } // uint32 opno = 2 [json_name = "opno"]; inline void NullIfExpr::clear_opno() { _impl_.opno_ = 0u; } inline uint32_t NullIfExpr::_internal_opno() const { return _impl_.opno_; } inline uint32_t NullIfExpr::opno() const { // @@protoc_insertion_point(field_get:pg_query.NullIfExpr.opno) return _internal_opno(); } inline void NullIfExpr::_internal_set_opno(uint32_t value) { _impl_.opno_ = value; } inline void NullIfExpr::set_opno(uint32_t value) { _internal_set_opno(value); // @@protoc_insertion_point(field_set:pg_query.NullIfExpr.opno) } // uint32 opfuncid = 3 [json_name = "opfuncid"]; inline void NullIfExpr::clear_opfuncid() { _impl_.opfuncid_ = 0u; } inline uint32_t NullIfExpr::_internal_opfuncid() const { return _impl_.opfuncid_; } inline uint32_t NullIfExpr::opfuncid() const { // @@protoc_insertion_point(field_get:pg_query.NullIfExpr.opfuncid) return _internal_opfuncid(); } inline void NullIfExpr::_internal_set_opfuncid(uint32_t value) { _impl_.opfuncid_ = value; } inline void NullIfExpr::set_opfuncid(uint32_t value) { _internal_set_opfuncid(value); // @@protoc_insertion_point(field_set:pg_query.NullIfExpr.opfuncid) } // uint32 opresulttype = 4 [json_name = "opresulttype"]; inline void NullIfExpr::clear_opresulttype() { _impl_.opresulttype_ = 0u; } inline uint32_t NullIfExpr::_internal_opresulttype() const { return _impl_.opresulttype_; } inline uint32_t NullIfExpr::opresulttype() const { // @@protoc_insertion_point(field_get:pg_query.NullIfExpr.opresulttype) return _internal_opresulttype(); } inline void NullIfExpr::_internal_set_opresulttype(uint32_t value) { _impl_.opresulttype_ = value; } inline void NullIfExpr::set_opresulttype(uint32_t value) { _internal_set_opresulttype(value); // @@protoc_insertion_point(field_set:pg_query.NullIfExpr.opresulttype) } // bool opretset = 5 [json_name = "opretset"]; inline void NullIfExpr::clear_opretset() { _impl_.opretset_ = false; } inline bool NullIfExpr::_internal_opretset() const { return _impl_.opretset_; } inline bool NullIfExpr::opretset() const { // @@protoc_insertion_point(field_get:pg_query.NullIfExpr.opretset) return _internal_opretset(); } inline void NullIfExpr::_internal_set_opretset(bool value) { _impl_.opretset_ = value; } inline void NullIfExpr::set_opretset(bool value) { _internal_set_opretset(value); // @@protoc_insertion_point(field_set:pg_query.NullIfExpr.opretset) } // uint32 opcollid = 6 [json_name = "opcollid"]; inline void NullIfExpr::clear_opcollid() { _impl_.opcollid_ = 0u; } inline uint32_t NullIfExpr::_internal_opcollid() const { return _impl_.opcollid_; } inline uint32_t NullIfExpr::opcollid() const { // @@protoc_insertion_point(field_get:pg_query.NullIfExpr.opcollid) return _internal_opcollid(); } inline void NullIfExpr::_internal_set_opcollid(uint32_t value) { _impl_.opcollid_ = value; } inline void NullIfExpr::set_opcollid(uint32_t value) { _internal_set_opcollid(value); // @@protoc_insertion_point(field_set:pg_query.NullIfExpr.opcollid) } // uint32 inputcollid = 7 [json_name = "inputcollid"]; inline void NullIfExpr::clear_inputcollid() { _impl_.inputcollid_ = 0u; } inline uint32_t NullIfExpr::_internal_inputcollid() const { return _impl_.inputcollid_; } inline uint32_t NullIfExpr::inputcollid() const { // @@protoc_insertion_point(field_get:pg_query.NullIfExpr.inputcollid) return _internal_inputcollid(); } inline void NullIfExpr::_internal_set_inputcollid(uint32_t value) { _impl_.inputcollid_ = value; } inline void NullIfExpr::set_inputcollid(uint32_t value) { _internal_set_inputcollid(value); // @@protoc_insertion_point(field_set:pg_query.NullIfExpr.inputcollid) } // repeated .pg_query.Node args = 8 [json_name = "args"]; inline int NullIfExpr::_internal_args_size() const { return _impl_.args_.size(); } inline int NullIfExpr::args_size() const { return _internal_args_size(); } inline void NullIfExpr::clear_args() { _impl_.args_.Clear(); } inline ::pg_query::Node* NullIfExpr::mutable_args(int index) { // @@protoc_insertion_point(field_mutable:pg_query.NullIfExpr.args) return _impl_.args_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* NullIfExpr::mutable_args() { // @@protoc_insertion_point(field_mutable_list:pg_query.NullIfExpr.args) return &_impl_.args_; } inline const ::pg_query::Node& NullIfExpr::_internal_args(int index) const { return _impl_.args_.Get(index); } inline const ::pg_query::Node& NullIfExpr::args(int index) const { // @@protoc_insertion_point(field_get:pg_query.NullIfExpr.args) return _internal_args(index); } inline ::pg_query::Node* NullIfExpr::_internal_add_args() { return _impl_.args_.Add(); } inline ::pg_query::Node* NullIfExpr::add_args() { ::pg_query::Node* _add = _internal_add_args(); // @@protoc_insertion_point(field_add:pg_query.NullIfExpr.args) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& NullIfExpr::args() const { // @@protoc_insertion_point(field_list:pg_query.NullIfExpr.args) return _impl_.args_; } // int32 location = 9 [json_name = "location"]; inline void NullIfExpr::clear_location() { _impl_.location_ = 0; } inline int32_t NullIfExpr::_internal_location() const { return _impl_.location_; } inline int32_t NullIfExpr::location() const { // @@protoc_insertion_point(field_get:pg_query.NullIfExpr.location) return _internal_location(); } inline void NullIfExpr::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void NullIfExpr::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.NullIfExpr.location) } // ------------------------------------------------------------------- // ScalarArrayOpExpr // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool ScalarArrayOpExpr::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool ScalarArrayOpExpr::has_xpr() const { return _internal_has_xpr(); } inline void ScalarArrayOpExpr::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& ScalarArrayOpExpr::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& ScalarArrayOpExpr::xpr() const { // @@protoc_insertion_point(field_get:pg_query.ScalarArrayOpExpr.xpr) return _internal_xpr(); } inline void ScalarArrayOpExpr::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ScalarArrayOpExpr.xpr) } inline ::pg_query::Node* ScalarArrayOpExpr::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* ScalarArrayOpExpr::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.ScalarArrayOpExpr.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* ScalarArrayOpExpr::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* ScalarArrayOpExpr::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.ScalarArrayOpExpr.xpr) } // uint32 opno = 2 [json_name = "opno"]; inline void ScalarArrayOpExpr::clear_opno() { _impl_.opno_ = 0u; } inline uint32_t ScalarArrayOpExpr::_internal_opno() const { return _impl_.opno_; } inline uint32_t ScalarArrayOpExpr::opno() const { // @@protoc_insertion_point(field_get:pg_query.ScalarArrayOpExpr.opno) return _internal_opno(); } inline void ScalarArrayOpExpr::_internal_set_opno(uint32_t value) { _impl_.opno_ = value; } inline void ScalarArrayOpExpr::set_opno(uint32_t value) { _internal_set_opno(value); // @@protoc_insertion_point(field_set:pg_query.ScalarArrayOpExpr.opno) } // uint32 opfuncid = 3 [json_name = "opfuncid"]; inline void ScalarArrayOpExpr::clear_opfuncid() { _impl_.opfuncid_ = 0u; } inline uint32_t ScalarArrayOpExpr::_internal_opfuncid() const { return _impl_.opfuncid_; } inline uint32_t ScalarArrayOpExpr::opfuncid() const { // @@protoc_insertion_point(field_get:pg_query.ScalarArrayOpExpr.opfuncid) return _internal_opfuncid(); } inline void ScalarArrayOpExpr::_internal_set_opfuncid(uint32_t value) { _impl_.opfuncid_ = value; } inline void ScalarArrayOpExpr::set_opfuncid(uint32_t value) { _internal_set_opfuncid(value); // @@protoc_insertion_point(field_set:pg_query.ScalarArrayOpExpr.opfuncid) } // uint32 hashfuncid = 4 [json_name = "hashfuncid"]; inline void ScalarArrayOpExpr::clear_hashfuncid() { _impl_.hashfuncid_ = 0u; } inline uint32_t ScalarArrayOpExpr::_internal_hashfuncid() const { return _impl_.hashfuncid_; } inline uint32_t ScalarArrayOpExpr::hashfuncid() const { // @@protoc_insertion_point(field_get:pg_query.ScalarArrayOpExpr.hashfuncid) return _internal_hashfuncid(); } inline void ScalarArrayOpExpr::_internal_set_hashfuncid(uint32_t value) { _impl_.hashfuncid_ = value; } inline void ScalarArrayOpExpr::set_hashfuncid(uint32_t value) { _internal_set_hashfuncid(value); // @@protoc_insertion_point(field_set:pg_query.ScalarArrayOpExpr.hashfuncid) } // uint32 negfuncid = 5 [json_name = "negfuncid"]; inline void ScalarArrayOpExpr::clear_negfuncid() { _impl_.negfuncid_ = 0u; } inline uint32_t ScalarArrayOpExpr::_internal_negfuncid() const { return _impl_.negfuncid_; } inline uint32_t ScalarArrayOpExpr::negfuncid() const { // @@protoc_insertion_point(field_get:pg_query.ScalarArrayOpExpr.negfuncid) return _internal_negfuncid(); } inline void ScalarArrayOpExpr::_internal_set_negfuncid(uint32_t value) { _impl_.negfuncid_ = value; } inline void ScalarArrayOpExpr::set_negfuncid(uint32_t value) { _internal_set_negfuncid(value); // @@protoc_insertion_point(field_set:pg_query.ScalarArrayOpExpr.negfuncid) } // bool use_or = 6 [json_name = "useOr"]; inline void ScalarArrayOpExpr::clear_use_or() { _impl_.use_or_ = false; } inline bool ScalarArrayOpExpr::_internal_use_or() const { return _impl_.use_or_; } inline bool ScalarArrayOpExpr::use_or() const { // @@protoc_insertion_point(field_get:pg_query.ScalarArrayOpExpr.use_or) return _internal_use_or(); } inline void ScalarArrayOpExpr::_internal_set_use_or(bool value) { _impl_.use_or_ = value; } inline void ScalarArrayOpExpr::set_use_or(bool value) { _internal_set_use_or(value); // @@protoc_insertion_point(field_set:pg_query.ScalarArrayOpExpr.use_or) } // uint32 inputcollid = 7 [json_name = "inputcollid"]; inline void ScalarArrayOpExpr::clear_inputcollid() { _impl_.inputcollid_ = 0u; } inline uint32_t ScalarArrayOpExpr::_internal_inputcollid() const { return _impl_.inputcollid_; } inline uint32_t ScalarArrayOpExpr::inputcollid() const { // @@protoc_insertion_point(field_get:pg_query.ScalarArrayOpExpr.inputcollid) return _internal_inputcollid(); } inline void ScalarArrayOpExpr::_internal_set_inputcollid(uint32_t value) { _impl_.inputcollid_ = value; } inline void ScalarArrayOpExpr::set_inputcollid(uint32_t value) { _internal_set_inputcollid(value); // @@protoc_insertion_point(field_set:pg_query.ScalarArrayOpExpr.inputcollid) } // repeated .pg_query.Node args = 8 [json_name = "args"]; inline int ScalarArrayOpExpr::_internal_args_size() const { return _impl_.args_.size(); } inline int ScalarArrayOpExpr::args_size() const { return _internal_args_size(); } inline void ScalarArrayOpExpr::clear_args() { _impl_.args_.Clear(); } inline ::pg_query::Node* ScalarArrayOpExpr::mutable_args(int index) { // @@protoc_insertion_point(field_mutable:pg_query.ScalarArrayOpExpr.args) return _impl_.args_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* ScalarArrayOpExpr::mutable_args() { // @@protoc_insertion_point(field_mutable_list:pg_query.ScalarArrayOpExpr.args) return &_impl_.args_; } inline const ::pg_query::Node& ScalarArrayOpExpr::_internal_args(int index) const { return _impl_.args_.Get(index); } inline const ::pg_query::Node& ScalarArrayOpExpr::args(int index) const { // @@protoc_insertion_point(field_get:pg_query.ScalarArrayOpExpr.args) return _internal_args(index); } inline ::pg_query::Node* ScalarArrayOpExpr::_internal_add_args() { return _impl_.args_.Add(); } inline ::pg_query::Node* ScalarArrayOpExpr::add_args() { ::pg_query::Node* _add = _internal_add_args(); // @@protoc_insertion_point(field_add:pg_query.ScalarArrayOpExpr.args) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& ScalarArrayOpExpr::args() const { // @@protoc_insertion_point(field_list:pg_query.ScalarArrayOpExpr.args) return _impl_.args_; } // int32 location = 9 [json_name = "location"]; inline void ScalarArrayOpExpr::clear_location() { _impl_.location_ = 0; } inline int32_t ScalarArrayOpExpr::_internal_location() const { return _impl_.location_; } inline int32_t ScalarArrayOpExpr::location() const { // @@protoc_insertion_point(field_get:pg_query.ScalarArrayOpExpr.location) return _internal_location(); } inline void ScalarArrayOpExpr::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void ScalarArrayOpExpr::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.ScalarArrayOpExpr.location) } // ------------------------------------------------------------------- // BoolExpr // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool BoolExpr::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool BoolExpr::has_xpr() const { return _internal_has_xpr(); } inline void BoolExpr::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& BoolExpr::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& BoolExpr::xpr() const { // @@protoc_insertion_point(field_get:pg_query.BoolExpr.xpr) return _internal_xpr(); } inline void BoolExpr::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.BoolExpr.xpr) } inline ::pg_query::Node* BoolExpr::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* BoolExpr::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.BoolExpr.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* BoolExpr::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* BoolExpr::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.BoolExpr.xpr) } // .pg_query.BoolExprType boolop = 2 [json_name = "boolop"]; inline void BoolExpr::clear_boolop() { _impl_.boolop_ = 0; } inline ::pg_query::BoolExprType BoolExpr::_internal_boolop() const { return static_cast< ::pg_query::BoolExprType >(_impl_.boolop_); } inline ::pg_query::BoolExprType BoolExpr::boolop() const { // @@protoc_insertion_point(field_get:pg_query.BoolExpr.boolop) return _internal_boolop(); } inline void BoolExpr::_internal_set_boolop(::pg_query::BoolExprType value) { _impl_.boolop_ = value; } inline void BoolExpr::set_boolop(::pg_query::BoolExprType value) { _internal_set_boolop(value); // @@protoc_insertion_point(field_set:pg_query.BoolExpr.boolop) } // repeated .pg_query.Node args = 3 [json_name = "args"]; inline int BoolExpr::_internal_args_size() const { return _impl_.args_.size(); } inline int BoolExpr::args_size() const { return _internal_args_size(); } inline void BoolExpr::clear_args() { _impl_.args_.Clear(); } inline ::pg_query::Node* BoolExpr::mutable_args(int index) { // @@protoc_insertion_point(field_mutable:pg_query.BoolExpr.args) return _impl_.args_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* BoolExpr::mutable_args() { // @@protoc_insertion_point(field_mutable_list:pg_query.BoolExpr.args) return &_impl_.args_; } inline const ::pg_query::Node& BoolExpr::_internal_args(int index) const { return _impl_.args_.Get(index); } inline const ::pg_query::Node& BoolExpr::args(int index) const { // @@protoc_insertion_point(field_get:pg_query.BoolExpr.args) return _internal_args(index); } inline ::pg_query::Node* BoolExpr::_internal_add_args() { return _impl_.args_.Add(); } inline ::pg_query::Node* BoolExpr::add_args() { ::pg_query::Node* _add = _internal_add_args(); // @@protoc_insertion_point(field_add:pg_query.BoolExpr.args) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& BoolExpr::args() const { // @@protoc_insertion_point(field_list:pg_query.BoolExpr.args) return _impl_.args_; } // int32 location = 4 [json_name = "location"]; inline void BoolExpr::clear_location() { _impl_.location_ = 0; } inline int32_t BoolExpr::_internal_location() const { return _impl_.location_; } inline int32_t BoolExpr::location() const { // @@protoc_insertion_point(field_get:pg_query.BoolExpr.location) return _internal_location(); } inline void BoolExpr::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void BoolExpr::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.BoolExpr.location) } // ------------------------------------------------------------------- // SubLink // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool SubLink::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool SubLink::has_xpr() const { return _internal_has_xpr(); } inline void SubLink::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& SubLink::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& SubLink::xpr() const { // @@protoc_insertion_point(field_get:pg_query.SubLink.xpr) return _internal_xpr(); } inline void SubLink::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SubLink.xpr) } inline ::pg_query::Node* SubLink::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* SubLink::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.SubLink.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* SubLink::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* SubLink::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.SubLink.xpr) } // .pg_query.SubLinkType sub_link_type = 2 [json_name = "subLinkType"]; inline void SubLink::clear_sub_link_type() { _impl_.sub_link_type_ = 0; } inline ::pg_query::SubLinkType SubLink::_internal_sub_link_type() const { return static_cast< ::pg_query::SubLinkType >(_impl_.sub_link_type_); } inline ::pg_query::SubLinkType SubLink::sub_link_type() const { // @@protoc_insertion_point(field_get:pg_query.SubLink.sub_link_type) return _internal_sub_link_type(); } inline void SubLink::_internal_set_sub_link_type(::pg_query::SubLinkType value) { _impl_.sub_link_type_ = value; } inline void SubLink::set_sub_link_type(::pg_query::SubLinkType value) { _internal_set_sub_link_type(value); // @@protoc_insertion_point(field_set:pg_query.SubLink.sub_link_type) } // int32 sub_link_id = 3 [json_name = "subLinkId"]; inline void SubLink::clear_sub_link_id() { _impl_.sub_link_id_ = 0; } inline int32_t SubLink::_internal_sub_link_id() const { return _impl_.sub_link_id_; } 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::_internal_set_sub_link_id(int32_t value) { _impl_.sub_link_id_ = value; } 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) } // .pg_query.Node testexpr = 4 [json_name = "testexpr"]; inline bool SubLink::_internal_has_testexpr() const { return this != internal_default_instance() && _impl_.testexpr_ != nullptr; } inline bool SubLink::has_testexpr() const { return _internal_has_testexpr(); } inline void SubLink::clear_testexpr() { if (GetArenaForAllocation() == nullptr && _impl_.testexpr_ != nullptr) { delete _impl_.testexpr_; } _impl_.testexpr_ = nullptr; } inline const ::pg_query::Node& SubLink::_internal_testexpr() const { const ::pg_query::Node* p = _impl_.testexpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& SubLink::testexpr() const { // @@protoc_insertion_point(field_get:pg_query.SubLink.testexpr) return _internal_testexpr(); } inline void SubLink::unsafe_arena_set_allocated_testexpr( ::pg_query::Node* testexpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.testexpr_); } _impl_.testexpr_ = testexpr; if (testexpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SubLink.testexpr) } inline ::pg_query::Node* SubLink::release_testexpr() { ::pg_query::Node* temp = _impl_.testexpr_; _impl_.testexpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* SubLink::unsafe_arena_release_testexpr() { // @@protoc_insertion_point(field_release:pg_query.SubLink.testexpr) ::pg_query::Node* temp = _impl_.testexpr_; _impl_.testexpr_ = nullptr; return temp; } inline ::pg_query::Node* SubLink::_internal_mutable_testexpr() { if (_impl_.testexpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.testexpr_ = p; } return _impl_.testexpr_; } inline ::pg_query::Node* SubLink::mutable_testexpr() { ::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* testexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.testexpr_; } if (testexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(testexpr); if (message_arena != submessage_arena) { testexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, testexpr, submessage_arena); } } else { } _impl_.testexpr_ = testexpr; // @@protoc_insertion_point(field_set_allocated:pg_query.SubLink.testexpr) } // repeated .pg_query.Node oper_name = 5 [json_name = "operName"]; inline int SubLink::_internal_oper_name_size() const { return _impl_.oper_name_.size(); } inline int SubLink::oper_name_size() const { return _internal_oper_name_size(); } inline void SubLink::clear_oper_name() { _impl_.oper_name_.Clear(); } inline ::pg_query::Node* SubLink::mutable_oper_name(int index) { // @@protoc_insertion_point(field_mutable:pg_query.SubLink.oper_name) return _impl_.oper_name_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* SubLink::mutable_oper_name() { // @@protoc_insertion_point(field_mutable_list:pg_query.SubLink.oper_name) return &_impl_.oper_name_; } inline const ::pg_query::Node& SubLink::_internal_oper_name(int index) const { return _impl_.oper_name_.Get(index); } inline const ::pg_query::Node& SubLink::oper_name(int index) const { // @@protoc_insertion_point(field_get:pg_query.SubLink.oper_name) return _internal_oper_name(index); } inline ::pg_query::Node* SubLink::_internal_add_oper_name() { return _impl_.oper_name_.Add(); } inline ::pg_query::Node* SubLink::add_oper_name() { ::pg_query::Node* _add = _internal_add_oper_name(); // @@protoc_insertion_point(field_add:pg_query.SubLink.oper_name) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& SubLink::oper_name() const { // @@protoc_insertion_point(field_list:pg_query.SubLink.oper_name) return _impl_.oper_name_; } // .pg_query.Node subselect = 6 [json_name = "subselect"]; inline bool SubLink::_internal_has_subselect() const { return this != internal_default_instance() && _impl_.subselect_ != nullptr; } inline bool SubLink::has_subselect() const { return _internal_has_subselect(); } inline void SubLink::clear_subselect() { if (GetArenaForAllocation() == nullptr && _impl_.subselect_ != nullptr) { delete _impl_.subselect_; } _impl_.subselect_ = nullptr; } inline const ::pg_query::Node& SubLink::_internal_subselect() const { const ::pg_query::Node* p = _impl_.subselect_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& SubLink::subselect() const { // @@protoc_insertion_point(field_get:pg_query.SubLink.subselect) return _internal_subselect(); } inline void SubLink::unsafe_arena_set_allocated_subselect( ::pg_query::Node* subselect) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.subselect_); } _impl_.subselect_ = subselect; if (subselect) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SubLink.subselect) } inline ::pg_query::Node* SubLink::release_subselect() { ::pg_query::Node* temp = _impl_.subselect_; _impl_.subselect_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* SubLink::unsafe_arena_release_subselect() { // @@protoc_insertion_point(field_release:pg_query.SubLink.subselect) ::pg_query::Node* temp = _impl_.subselect_; _impl_.subselect_ = nullptr; return temp; } inline ::pg_query::Node* SubLink::_internal_mutable_subselect() { if (_impl_.subselect_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.subselect_ = p; } return _impl_.subselect_; } inline ::pg_query::Node* SubLink::mutable_subselect() { ::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* subselect) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.subselect_; } if (subselect) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(subselect); if (message_arena != submessage_arena) { subselect = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, subselect, submessage_arena); } } else { } _impl_.subselect_ = subselect; // @@protoc_insertion_point(field_set_allocated:pg_query.SubLink.subselect) } // int32 location = 7 [json_name = "location"]; inline void SubLink::clear_location() { _impl_.location_ = 0; } inline int32_t SubLink::_internal_location() const { return _impl_.location_; } inline int32_t SubLink::location() const { // @@protoc_insertion_point(field_get:pg_query.SubLink.location) return _internal_location(); } inline void SubLink::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void SubLink::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.SubLink.location) } // ------------------------------------------------------------------- // SubPlan // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool SubPlan::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool SubPlan::has_xpr() const { return _internal_has_xpr(); } inline void SubPlan::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& SubPlan::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& SubPlan::xpr() const { // @@protoc_insertion_point(field_get:pg_query.SubPlan.xpr) return _internal_xpr(); } inline void SubPlan::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SubPlan.xpr) } inline ::pg_query::Node* SubPlan::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* SubPlan::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.SubPlan.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* SubPlan::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* SubPlan::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.SubPlan.xpr) } // .pg_query.SubLinkType sub_link_type = 2 [json_name = "subLinkType"]; inline void SubPlan::clear_sub_link_type() { _impl_.sub_link_type_ = 0; } inline ::pg_query::SubLinkType SubPlan::_internal_sub_link_type() const { return static_cast< ::pg_query::SubLinkType >(_impl_.sub_link_type_); } inline ::pg_query::SubLinkType SubPlan::sub_link_type() const { // @@protoc_insertion_point(field_get:pg_query.SubPlan.sub_link_type) return _internal_sub_link_type(); } inline void SubPlan::_internal_set_sub_link_type(::pg_query::SubLinkType value) { _impl_.sub_link_type_ = value; } inline void SubPlan::set_sub_link_type(::pg_query::SubLinkType value) { _internal_set_sub_link_type(value); // @@protoc_insertion_point(field_set:pg_query.SubPlan.sub_link_type) } // .pg_query.Node testexpr = 3 [json_name = "testexpr"]; inline bool SubPlan::_internal_has_testexpr() const { return this != internal_default_instance() && _impl_.testexpr_ != nullptr; } inline bool SubPlan::has_testexpr() const { return _internal_has_testexpr(); } inline void SubPlan::clear_testexpr() { if (GetArenaForAllocation() == nullptr && _impl_.testexpr_ != nullptr) { delete _impl_.testexpr_; } _impl_.testexpr_ = nullptr; } inline const ::pg_query::Node& SubPlan::_internal_testexpr() const { const ::pg_query::Node* p = _impl_.testexpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& SubPlan::testexpr() const { // @@protoc_insertion_point(field_get:pg_query.SubPlan.testexpr) return _internal_testexpr(); } inline void SubPlan::unsafe_arena_set_allocated_testexpr( ::pg_query::Node* testexpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.testexpr_); } _impl_.testexpr_ = testexpr; if (testexpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SubPlan.testexpr) } inline ::pg_query::Node* SubPlan::release_testexpr() { ::pg_query::Node* temp = _impl_.testexpr_; _impl_.testexpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* SubPlan::unsafe_arena_release_testexpr() { // @@protoc_insertion_point(field_release:pg_query.SubPlan.testexpr) ::pg_query::Node* temp = _impl_.testexpr_; _impl_.testexpr_ = nullptr; return temp; } inline ::pg_query::Node* SubPlan::_internal_mutable_testexpr() { if (_impl_.testexpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.testexpr_ = p; } return _impl_.testexpr_; } inline ::pg_query::Node* SubPlan::mutable_testexpr() { ::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* testexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.testexpr_; } if (testexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(testexpr); if (message_arena != submessage_arena) { testexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, testexpr, submessage_arena); } } else { } _impl_.testexpr_ = testexpr; // @@protoc_insertion_point(field_set_allocated:pg_query.SubPlan.testexpr) } // repeated .pg_query.Node param_ids = 4 [json_name = "paramIds"]; inline int SubPlan::_internal_param_ids_size() const { return _impl_.param_ids_.size(); } inline int SubPlan::param_ids_size() const { return _internal_param_ids_size(); } inline void SubPlan::clear_param_ids() { _impl_.param_ids_.Clear(); } inline ::pg_query::Node* SubPlan::mutable_param_ids(int index) { // @@protoc_insertion_point(field_mutable:pg_query.SubPlan.param_ids) return _impl_.param_ids_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* SubPlan::mutable_param_ids() { // @@protoc_insertion_point(field_mutable_list:pg_query.SubPlan.param_ids) return &_impl_.param_ids_; } inline const ::pg_query::Node& SubPlan::_internal_param_ids(int index) const { return _impl_.param_ids_.Get(index); } inline const ::pg_query::Node& SubPlan::param_ids(int index) const { // @@protoc_insertion_point(field_get:pg_query.SubPlan.param_ids) return _internal_param_ids(index); } inline ::pg_query::Node* SubPlan::_internal_add_param_ids() { return _impl_.param_ids_.Add(); } inline ::pg_query::Node* SubPlan::add_param_ids() { ::pg_query::Node* _add = _internal_add_param_ids(); // @@protoc_insertion_point(field_add:pg_query.SubPlan.param_ids) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& SubPlan::param_ids() const { // @@protoc_insertion_point(field_list:pg_query.SubPlan.param_ids) return _impl_.param_ids_; } // int32 plan_id = 5 [json_name = "plan_id"]; inline void SubPlan::clear_plan_id() { _impl_.plan_id_ = 0; } inline int32_t SubPlan::_internal_plan_id() const { return _impl_.plan_id_; } inline int32_t SubPlan::plan_id() const { // @@protoc_insertion_point(field_get:pg_query.SubPlan.plan_id) return _internal_plan_id(); } inline void SubPlan::_internal_set_plan_id(int32_t value) { _impl_.plan_id_ = value; } inline void SubPlan::set_plan_id(int32_t value) { _internal_set_plan_id(value); // @@protoc_insertion_point(field_set:pg_query.SubPlan.plan_id) } // string plan_name = 6 [json_name = "plan_name"]; inline void SubPlan::clear_plan_name() { _impl_.plan_name_.ClearToEmpty(); } inline const std::string& SubPlan::plan_name() const { // @@protoc_insertion_point(field_get:pg_query.SubPlan.plan_name) return _internal_plan_name(); } template inline PROTOBUF_ALWAYS_INLINE void SubPlan::set_plan_name(ArgT0&& arg0, ArgT... args) { _impl_.plan_name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.SubPlan.plan_name) } inline std::string* SubPlan::mutable_plan_name() { 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 { return _impl_.plan_name_.Get(); } inline void SubPlan::_internal_set_plan_name(const std::string& value) { _impl_.plan_name_.Set(value, GetArenaForAllocation()); } inline std::string* SubPlan::_internal_mutable_plan_name() { return _impl_.plan_name_.Mutable(GetArenaForAllocation()); } inline std::string* SubPlan::release_plan_name() { // @@protoc_insertion_point(field_release:pg_query.SubPlan.plan_name) return _impl_.plan_name_.Release(); } inline void SubPlan::set_allocated_plan_name(std::string* plan_name) { if (plan_name != nullptr) { } else { } _impl_.plan_name_.SetAllocated(plan_name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.plan_name_.IsDefault()) { _impl_.plan_name_.Set("", GetArenaForAllocation()); } #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() { _impl_.first_col_type_ = 0u; } inline uint32_t SubPlan::_internal_first_col_type() const { return _impl_.first_col_type_; } 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::_internal_set_first_col_type(uint32_t value) { _impl_.first_col_type_ = value; } 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) } // int32 first_col_typmod = 8 [json_name = "firstColTypmod"]; inline void SubPlan::clear_first_col_typmod() { _impl_.first_col_typmod_ = 0; } inline int32_t SubPlan::_internal_first_col_typmod() const { return _impl_.first_col_typmod_; } 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::_internal_set_first_col_typmod(int32_t value) { _impl_.first_col_typmod_ = value; } 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) } // uint32 first_col_collation = 9 [json_name = "firstColCollation"]; inline void SubPlan::clear_first_col_collation() { _impl_.first_col_collation_ = 0u; } inline uint32_t SubPlan::_internal_first_col_collation() const { return _impl_.first_col_collation_; } 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::_internal_set_first_col_collation(uint32_t value) { _impl_.first_col_collation_ = value; } 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) } // bool use_hash_table = 10 [json_name = "useHashTable"]; inline void SubPlan::clear_use_hash_table() { _impl_.use_hash_table_ = false; } inline bool SubPlan::_internal_use_hash_table() const { return _impl_.use_hash_table_; } inline bool SubPlan::use_hash_table() const { // @@protoc_insertion_point(field_get:pg_query.SubPlan.use_hash_table) return _internal_use_hash_table(); } inline void SubPlan::_internal_set_use_hash_table(bool value) { _impl_.use_hash_table_ = value; } inline void SubPlan::set_use_hash_table(bool value) { _internal_set_use_hash_table(value); // @@protoc_insertion_point(field_set:pg_query.SubPlan.use_hash_table) } // bool unknown_eq_false = 11 [json_name = "unknownEqFalse"]; inline void SubPlan::clear_unknown_eq_false() { _impl_.unknown_eq_false_ = false; } inline bool SubPlan::_internal_unknown_eq_false() const { return _impl_.unknown_eq_false_; } inline bool SubPlan::unknown_eq_false() const { // @@protoc_insertion_point(field_get:pg_query.SubPlan.unknown_eq_false) return _internal_unknown_eq_false(); } inline void SubPlan::_internal_set_unknown_eq_false(bool value) { _impl_.unknown_eq_false_ = value; } inline void SubPlan::set_unknown_eq_false(bool value) { _internal_set_unknown_eq_false(value); // @@protoc_insertion_point(field_set:pg_query.SubPlan.unknown_eq_false) } // bool parallel_safe = 12 [json_name = "parallel_safe"]; inline void SubPlan::clear_parallel_safe() { _impl_.parallel_safe_ = false; } inline bool SubPlan::_internal_parallel_safe() const { return _impl_.parallel_safe_; } inline bool SubPlan::parallel_safe() const { // @@protoc_insertion_point(field_get:pg_query.SubPlan.parallel_safe) return _internal_parallel_safe(); } inline void SubPlan::_internal_set_parallel_safe(bool value) { _impl_.parallel_safe_ = value; } inline void SubPlan::set_parallel_safe(bool value) { _internal_set_parallel_safe(value); // @@protoc_insertion_point(field_set:pg_query.SubPlan.parallel_safe) } // repeated .pg_query.Node set_param = 13 [json_name = "setParam"]; inline int SubPlan::_internal_set_param_size() const { return _impl_.set_param_.size(); } inline int SubPlan::set_param_size() const { return _internal_set_param_size(); } inline void SubPlan::clear_set_param() { _impl_.set_param_.Clear(); } inline ::pg_query::Node* SubPlan::mutable_set_param(int index) { // @@protoc_insertion_point(field_mutable:pg_query.SubPlan.set_param) return _impl_.set_param_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* SubPlan::mutable_set_param() { // @@protoc_insertion_point(field_mutable_list:pg_query.SubPlan.set_param) return &_impl_.set_param_; } inline const ::pg_query::Node& SubPlan::_internal_set_param(int index) const { return _impl_.set_param_.Get(index); } inline const ::pg_query::Node& SubPlan::set_param(int index) const { // @@protoc_insertion_point(field_get:pg_query.SubPlan.set_param) return _internal_set_param(index); } inline ::pg_query::Node* SubPlan::_internal_add_set_param() { return _impl_.set_param_.Add(); } inline ::pg_query::Node* SubPlan::add_set_param() { ::pg_query::Node* _add = _internal_add_set_param(); // @@protoc_insertion_point(field_add:pg_query.SubPlan.set_param) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& SubPlan::set_param() const { // @@protoc_insertion_point(field_list:pg_query.SubPlan.set_param) return _impl_.set_param_; } // repeated .pg_query.Node par_param = 14 [json_name = "parParam"]; inline int SubPlan::_internal_par_param_size() const { return _impl_.par_param_.size(); } inline int SubPlan::par_param_size() const { return _internal_par_param_size(); } inline void SubPlan::clear_par_param() { _impl_.par_param_.Clear(); } inline ::pg_query::Node* SubPlan::mutable_par_param(int index) { // @@protoc_insertion_point(field_mutable:pg_query.SubPlan.par_param) return _impl_.par_param_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* SubPlan::mutable_par_param() { // @@protoc_insertion_point(field_mutable_list:pg_query.SubPlan.par_param) return &_impl_.par_param_; } inline const ::pg_query::Node& SubPlan::_internal_par_param(int index) const { return _impl_.par_param_.Get(index); } inline const ::pg_query::Node& SubPlan::par_param(int index) const { // @@protoc_insertion_point(field_get:pg_query.SubPlan.par_param) return _internal_par_param(index); } inline ::pg_query::Node* SubPlan::_internal_add_par_param() { return _impl_.par_param_.Add(); } inline ::pg_query::Node* SubPlan::add_par_param() { ::pg_query::Node* _add = _internal_add_par_param(); // @@protoc_insertion_point(field_add:pg_query.SubPlan.par_param) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& SubPlan::par_param() const { // @@protoc_insertion_point(field_list:pg_query.SubPlan.par_param) return _impl_.par_param_; } // repeated .pg_query.Node args = 15 [json_name = "args"]; inline int SubPlan::_internal_args_size() const { return _impl_.args_.size(); } inline int SubPlan::args_size() const { return _internal_args_size(); } inline void SubPlan::clear_args() { _impl_.args_.Clear(); } inline ::pg_query::Node* SubPlan::mutable_args(int index) { // @@protoc_insertion_point(field_mutable:pg_query.SubPlan.args) return _impl_.args_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* SubPlan::mutable_args() { // @@protoc_insertion_point(field_mutable_list:pg_query.SubPlan.args) return &_impl_.args_; } inline const ::pg_query::Node& SubPlan::_internal_args(int index) const { return _impl_.args_.Get(index); } inline const ::pg_query::Node& SubPlan::args(int index) const { // @@protoc_insertion_point(field_get:pg_query.SubPlan.args) return _internal_args(index); } inline ::pg_query::Node* SubPlan::_internal_add_args() { return _impl_.args_.Add(); } inline ::pg_query::Node* SubPlan::add_args() { ::pg_query::Node* _add = _internal_add_args(); // @@protoc_insertion_point(field_add:pg_query.SubPlan.args) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& SubPlan::args() const { // @@protoc_insertion_point(field_list:pg_query.SubPlan.args) return _impl_.args_; } // double startup_cost = 16 [json_name = "startup_cost"]; inline void SubPlan::clear_startup_cost() { _impl_.startup_cost_ = 0; } inline double SubPlan::_internal_startup_cost() const { return _impl_.startup_cost_; } inline double SubPlan::startup_cost() const { // @@protoc_insertion_point(field_get:pg_query.SubPlan.startup_cost) return _internal_startup_cost(); } inline void SubPlan::_internal_set_startup_cost(double value) { _impl_.startup_cost_ = value; } inline void SubPlan::set_startup_cost(double value) { _internal_set_startup_cost(value); // @@protoc_insertion_point(field_set:pg_query.SubPlan.startup_cost) } // double per_call_cost = 17 [json_name = "per_call_cost"]; inline void SubPlan::clear_per_call_cost() { _impl_.per_call_cost_ = 0; } inline double SubPlan::_internal_per_call_cost() const { return _impl_.per_call_cost_; } inline double SubPlan::per_call_cost() const { // @@protoc_insertion_point(field_get:pg_query.SubPlan.per_call_cost) return _internal_per_call_cost(); } inline void SubPlan::_internal_set_per_call_cost(double value) { _impl_.per_call_cost_ = value; } inline void SubPlan::set_per_call_cost(double value) { _internal_set_per_call_cost(value); // @@protoc_insertion_point(field_set:pg_query.SubPlan.per_call_cost) } // ------------------------------------------------------------------- // AlternativeSubPlan // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool AlternativeSubPlan::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool AlternativeSubPlan::has_xpr() const { return _internal_has_xpr(); } inline void AlternativeSubPlan::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& AlternativeSubPlan::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& AlternativeSubPlan::xpr() const { // @@protoc_insertion_point(field_get:pg_query.AlternativeSubPlan.xpr) return _internal_xpr(); } inline void AlternativeSubPlan::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlternativeSubPlan.xpr) } inline ::pg_query::Node* AlternativeSubPlan::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* AlternativeSubPlan::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.AlternativeSubPlan.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* AlternativeSubPlan::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* AlternativeSubPlan::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.AlternativeSubPlan.xpr) } // repeated .pg_query.Node subplans = 2 [json_name = "subplans"]; inline int AlternativeSubPlan::_internal_subplans_size() const { return _impl_.subplans_.size(); } inline int AlternativeSubPlan::subplans_size() const { return _internal_subplans_size(); } inline void AlternativeSubPlan::clear_subplans() { _impl_.subplans_.Clear(); } inline ::pg_query::Node* AlternativeSubPlan::mutable_subplans(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlternativeSubPlan.subplans) return _impl_.subplans_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlternativeSubPlan::mutable_subplans() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlternativeSubPlan.subplans) return &_impl_.subplans_; } inline const ::pg_query::Node& AlternativeSubPlan::_internal_subplans(int index) const { return _impl_.subplans_.Get(index); } inline const ::pg_query::Node& AlternativeSubPlan::subplans(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlternativeSubPlan.subplans) return _internal_subplans(index); } inline ::pg_query::Node* AlternativeSubPlan::_internal_add_subplans() { return _impl_.subplans_.Add(); } inline ::pg_query::Node* AlternativeSubPlan::add_subplans() { ::pg_query::Node* _add = _internal_add_subplans(); // @@protoc_insertion_point(field_add:pg_query.AlternativeSubPlan.subplans) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlternativeSubPlan::subplans() const { // @@protoc_insertion_point(field_list:pg_query.AlternativeSubPlan.subplans) return _impl_.subplans_; } // ------------------------------------------------------------------- // FieldSelect // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool FieldSelect::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool FieldSelect::has_xpr() const { return _internal_has_xpr(); } inline void FieldSelect::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& FieldSelect::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& FieldSelect::xpr() const { // @@protoc_insertion_point(field_get:pg_query.FieldSelect.xpr) return _internal_xpr(); } inline void FieldSelect::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FieldSelect.xpr) } inline ::pg_query::Node* FieldSelect::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* FieldSelect::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.FieldSelect.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* FieldSelect::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* FieldSelect::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.FieldSelect.xpr) } // .pg_query.Node arg = 2 [json_name = "arg"]; inline bool FieldSelect::_internal_has_arg() const { return this != internal_default_instance() && _impl_.arg_ != nullptr; } inline bool FieldSelect::has_arg() const { return _internal_has_arg(); } inline void FieldSelect::clear_arg() { if (GetArenaForAllocation() == nullptr && _impl_.arg_ != nullptr) { delete _impl_.arg_; } _impl_.arg_ = nullptr; } inline const ::pg_query::Node& FieldSelect::_internal_arg() const { const ::pg_query::Node* p = _impl_.arg_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& FieldSelect::arg() const { // @@protoc_insertion_point(field_get:pg_query.FieldSelect.arg) return _internal_arg(); } inline void FieldSelect::unsafe_arena_set_allocated_arg( ::pg_query::Node* arg) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.arg_); } _impl_.arg_ = arg; if (arg) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FieldSelect.arg) } inline ::pg_query::Node* FieldSelect::release_arg() { ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* FieldSelect::unsafe_arena_release_arg() { // @@protoc_insertion_point(field_release:pg_query.FieldSelect.arg) ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; return temp; } inline ::pg_query::Node* FieldSelect::_internal_mutable_arg() { if (_impl_.arg_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.arg_ = p; } return _impl_.arg_; } inline ::pg_query::Node* FieldSelect::mutable_arg() { ::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* arg) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.arg_; } if (arg) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(arg); if (message_arena != submessage_arena) { arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, arg, submessage_arena); } } else { } _impl_.arg_ = arg; // @@protoc_insertion_point(field_set_allocated:pg_query.FieldSelect.arg) } // int32 fieldnum = 3 [json_name = "fieldnum"]; inline void FieldSelect::clear_fieldnum() { _impl_.fieldnum_ = 0; } inline int32_t FieldSelect::_internal_fieldnum() const { return _impl_.fieldnum_; } inline int32_t FieldSelect::fieldnum() const { // @@protoc_insertion_point(field_get:pg_query.FieldSelect.fieldnum) return _internal_fieldnum(); } inline void FieldSelect::_internal_set_fieldnum(int32_t value) { _impl_.fieldnum_ = value; } inline void FieldSelect::set_fieldnum(int32_t value) { _internal_set_fieldnum(value); // @@protoc_insertion_point(field_set:pg_query.FieldSelect.fieldnum) } // uint32 resulttype = 4 [json_name = "resulttype"]; inline void FieldSelect::clear_resulttype() { _impl_.resulttype_ = 0u; } inline uint32_t FieldSelect::_internal_resulttype() const { return _impl_.resulttype_; } inline uint32_t FieldSelect::resulttype() const { // @@protoc_insertion_point(field_get:pg_query.FieldSelect.resulttype) return _internal_resulttype(); } inline void FieldSelect::_internal_set_resulttype(uint32_t value) { _impl_.resulttype_ = value; } inline void FieldSelect::set_resulttype(uint32_t value) { _internal_set_resulttype(value); // @@protoc_insertion_point(field_set:pg_query.FieldSelect.resulttype) } // int32 resulttypmod = 5 [json_name = "resulttypmod"]; inline void FieldSelect::clear_resulttypmod() { _impl_.resulttypmod_ = 0; } inline int32_t FieldSelect::_internal_resulttypmod() const { return _impl_.resulttypmod_; } inline int32_t FieldSelect::resulttypmod() const { // @@protoc_insertion_point(field_get:pg_query.FieldSelect.resulttypmod) return _internal_resulttypmod(); } inline void FieldSelect::_internal_set_resulttypmod(int32_t value) { _impl_.resulttypmod_ = value; } inline void FieldSelect::set_resulttypmod(int32_t value) { _internal_set_resulttypmod(value); // @@protoc_insertion_point(field_set:pg_query.FieldSelect.resulttypmod) } // uint32 resultcollid = 6 [json_name = "resultcollid"]; inline void FieldSelect::clear_resultcollid() { _impl_.resultcollid_ = 0u; } inline uint32_t FieldSelect::_internal_resultcollid() const { return _impl_.resultcollid_; } inline uint32_t FieldSelect::resultcollid() const { // @@protoc_insertion_point(field_get:pg_query.FieldSelect.resultcollid) return _internal_resultcollid(); } inline void FieldSelect::_internal_set_resultcollid(uint32_t value) { _impl_.resultcollid_ = value; } inline void FieldSelect::set_resultcollid(uint32_t value) { _internal_set_resultcollid(value); // @@protoc_insertion_point(field_set:pg_query.FieldSelect.resultcollid) } // ------------------------------------------------------------------- // FieldStore // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool FieldStore::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool FieldStore::has_xpr() const { return _internal_has_xpr(); } inline void FieldStore::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& FieldStore::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& FieldStore::xpr() const { // @@protoc_insertion_point(field_get:pg_query.FieldStore.xpr) return _internal_xpr(); } inline void FieldStore::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FieldStore.xpr) } inline ::pg_query::Node* FieldStore::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* FieldStore::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.FieldStore.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* FieldStore::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* FieldStore::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.FieldStore.xpr) } // .pg_query.Node arg = 2 [json_name = "arg"]; inline bool FieldStore::_internal_has_arg() const { return this != internal_default_instance() && _impl_.arg_ != nullptr; } inline bool FieldStore::has_arg() const { return _internal_has_arg(); } inline void FieldStore::clear_arg() { if (GetArenaForAllocation() == nullptr && _impl_.arg_ != nullptr) { delete _impl_.arg_; } _impl_.arg_ = nullptr; } inline const ::pg_query::Node& FieldStore::_internal_arg() const { const ::pg_query::Node* p = _impl_.arg_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& FieldStore::arg() const { // @@protoc_insertion_point(field_get:pg_query.FieldStore.arg) return _internal_arg(); } inline void FieldStore::unsafe_arena_set_allocated_arg( ::pg_query::Node* arg) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.arg_); } _impl_.arg_ = arg; if (arg) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FieldStore.arg) } inline ::pg_query::Node* FieldStore::release_arg() { ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* FieldStore::unsafe_arena_release_arg() { // @@protoc_insertion_point(field_release:pg_query.FieldStore.arg) ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; return temp; } inline ::pg_query::Node* FieldStore::_internal_mutable_arg() { if (_impl_.arg_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.arg_ = p; } return _impl_.arg_; } inline ::pg_query::Node* FieldStore::mutable_arg() { ::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* arg) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.arg_; } if (arg) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(arg); if (message_arena != submessage_arena) { arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, arg, submessage_arena); } } else { } _impl_.arg_ = arg; // @@protoc_insertion_point(field_set_allocated:pg_query.FieldStore.arg) } // repeated .pg_query.Node newvals = 3 [json_name = "newvals"]; inline int FieldStore::_internal_newvals_size() const { return _impl_.newvals_.size(); } inline int FieldStore::newvals_size() const { return _internal_newvals_size(); } inline void FieldStore::clear_newvals() { _impl_.newvals_.Clear(); } inline ::pg_query::Node* FieldStore::mutable_newvals(int index) { // @@protoc_insertion_point(field_mutable:pg_query.FieldStore.newvals) return _impl_.newvals_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* FieldStore::mutable_newvals() { // @@protoc_insertion_point(field_mutable_list:pg_query.FieldStore.newvals) return &_impl_.newvals_; } inline const ::pg_query::Node& FieldStore::_internal_newvals(int index) const { return _impl_.newvals_.Get(index); } inline const ::pg_query::Node& FieldStore::newvals(int index) const { // @@protoc_insertion_point(field_get:pg_query.FieldStore.newvals) return _internal_newvals(index); } inline ::pg_query::Node* FieldStore::_internal_add_newvals() { return _impl_.newvals_.Add(); } inline ::pg_query::Node* FieldStore::add_newvals() { ::pg_query::Node* _add = _internal_add_newvals(); // @@protoc_insertion_point(field_add:pg_query.FieldStore.newvals) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& FieldStore::newvals() const { // @@protoc_insertion_point(field_list:pg_query.FieldStore.newvals) return _impl_.newvals_; } // repeated .pg_query.Node fieldnums = 4 [json_name = "fieldnums"]; inline int FieldStore::_internal_fieldnums_size() const { return _impl_.fieldnums_.size(); } inline int FieldStore::fieldnums_size() const { return _internal_fieldnums_size(); } inline void FieldStore::clear_fieldnums() { _impl_.fieldnums_.Clear(); } inline ::pg_query::Node* FieldStore::mutable_fieldnums(int index) { // @@protoc_insertion_point(field_mutable:pg_query.FieldStore.fieldnums) return _impl_.fieldnums_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* FieldStore::mutable_fieldnums() { // @@protoc_insertion_point(field_mutable_list:pg_query.FieldStore.fieldnums) return &_impl_.fieldnums_; } inline const ::pg_query::Node& FieldStore::_internal_fieldnums(int index) const { return _impl_.fieldnums_.Get(index); } inline const ::pg_query::Node& FieldStore::fieldnums(int index) const { // @@protoc_insertion_point(field_get:pg_query.FieldStore.fieldnums) return _internal_fieldnums(index); } inline ::pg_query::Node* FieldStore::_internal_add_fieldnums() { return _impl_.fieldnums_.Add(); } inline ::pg_query::Node* FieldStore::add_fieldnums() { ::pg_query::Node* _add = _internal_add_fieldnums(); // @@protoc_insertion_point(field_add:pg_query.FieldStore.fieldnums) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& FieldStore::fieldnums() const { // @@protoc_insertion_point(field_list:pg_query.FieldStore.fieldnums) return _impl_.fieldnums_; } // uint32 resulttype = 5 [json_name = "resulttype"]; inline void FieldStore::clear_resulttype() { _impl_.resulttype_ = 0u; } inline uint32_t FieldStore::_internal_resulttype() const { return _impl_.resulttype_; } inline uint32_t FieldStore::resulttype() const { // @@protoc_insertion_point(field_get:pg_query.FieldStore.resulttype) return _internal_resulttype(); } inline void FieldStore::_internal_set_resulttype(uint32_t value) { _impl_.resulttype_ = value; } inline void FieldStore::set_resulttype(uint32_t value) { _internal_set_resulttype(value); // @@protoc_insertion_point(field_set:pg_query.FieldStore.resulttype) } // ------------------------------------------------------------------- // RelabelType // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool RelabelType::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool RelabelType::has_xpr() const { return _internal_has_xpr(); } inline void RelabelType::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& RelabelType::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& RelabelType::xpr() const { // @@protoc_insertion_point(field_get:pg_query.RelabelType.xpr) return _internal_xpr(); } inline void RelabelType::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RelabelType.xpr) } inline ::pg_query::Node* RelabelType::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* RelabelType::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.RelabelType.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* RelabelType::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* RelabelType::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.RelabelType.xpr) } // .pg_query.Node arg = 2 [json_name = "arg"]; inline bool RelabelType::_internal_has_arg() const { return this != internal_default_instance() && _impl_.arg_ != nullptr; } inline bool RelabelType::has_arg() const { return _internal_has_arg(); } inline void RelabelType::clear_arg() { if (GetArenaForAllocation() == nullptr && _impl_.arg_ != nullptr) { delete _impl_.arg_; } _impl_.arg_ = nullptr; } inline const ::pg_query::Node& RelabelType::_internal_arg() const { const ::pg_query::Node* p = _impl_.arg_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& RelabelType::arg() const { // @@protoc_insertion_point(field_get:pg_query.RelabelType.arg) return _internal_arg(); } inline void RelabelType::unsafe_arena_set_allocated_arg( ::pg_query::Node* arg) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.arg_); } _impl_.arg_ = arg; if (arg) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RelabelType.arg) } inline ::pg_query::Node* RelabelType::release_arg() { ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* RelabelType::unsafe_arena_release_arg() { // @@protoc_insertion_point(field_release:pg_query.RelabelType.arg) ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; return temp; } inline ::pg_query::Node* RelabelType::_internal_mutable_arg() { if (_impl_.arg_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.arg_ = p; } return _impl_.arg_; } inline ::pg_query::Node* RelabelType::mutable_arg() { ::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* arg) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.arg_; } if (arg) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(arg); if (message_arena != submessage_arena) { arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, arg, submessage_arena); } } else { } _impl_.arg_ = arg; // @@protoc_insertion_point(field_set_allocated:pg_query.RelabelType.arg) } // uint32 resulttype = 3 [json_name = "resulttype"]; inline void RelabelType::clear_resulttype() { _impl_.resulttype_ = 0u; } inline uint32_t RelabelType::_internal_resulttype() const { return _impl_.resulttype_; } inline uint32_t RelabelType::resulttype() const { // @@protoc_insertion_point(field_get:pg_query.RelabelType.resulttype) return _internal_resulttype(); } inline void RelabelType::_internal_set_resulttype(uint32_t value) { _impl_.resulttype_ = value; } inline void RelabelType::set_resulttype(uint32_t value) { _internal_set_resulttype(value); // @@protoc_insertion_point(field_set:pg_query.RelabelType.resulttype) } // int32 resulttypmod = 4 [json_name = "resulttypmod"]; inline void RelabelType::clear_resulttypmod() { _impl_.resulttypmod_ = 0; } inline int32_t RelabelType::_internal_resulttypmod() const { return _impl_.resulttypmod_; } inline int32_t RelabelType::resulttypmod() const { // @@protoc_insertion_point(field_get:pg_query.RelabelType.resulttypmod) return _internal_resulttypmod(); } inline void RelabelType::_internal_set_resulttypmod(int32_t value) { _impl_.resulttypmod_ = value; } inline void RelabelType::set_resulttypmod(int32_t value) { _internal_set_resulttypmod(value); // @@protoc_insertion_point(field_set:pg_query.RelabelType.resulttypmod) } // uint32 resultcollid = 5 [json_name = "resultcollid"]; inline void RelabelType::clear_resultcollid() { _impl_.resultcollid_ = 0u; } inline uint32_t RelabelType::_internal_resultcollid() const { return _impl_.resultcollid_; } inline uint32_t RelabelType::resultcollid() const { // @@protoc_insertion_point(field_get:pg_query.RelabelType.resultcollid) return _internal_resultcollid(); } inline void RelabelType::_internal_set_resultcollid(uint32_t value) { _impl_.resultcollid_ = value; } inline void RelabelType::set_resultcollid(uint32_t value) { _internal_set_resultcollid(value); // @@protoc_insertion_point(field_set:pg_query.RelabelType.resultcollid) } // .pg_query.CoercionForm relabelformat = 6 [json_name = "relabelformat"]; inline void RelabelType::clear_relabelformat() { _impl_.relabelformat_ = 0; } inline ::pg_query::CoercionForm RelabelType::_internal_relabelformat() const { return static_cast< ::pg_query::CoercionForm >(_impl_.relabelformat_); } inline ::pg_query::CoercionForm RelabelType::relabelformat() const { // @@protoc_insertion_point(field_get:pg_query.RelabelType.relabelformat) return _internal_relabelformat(); } inline void RelabelType::_internal_set_relabelformat(::pg_query::CoercionForm value) { _impl_.relabelformat_ = value; } inline void RelabelType::set_relabelformat(::pg_query::CoercionForm value) { _internal_set_relabelformat(value); // @@protoc_insertion_point(field_set:pg_query.RelabelType.relabelformat) } // int32 location = 7 [json_name = "location"]; inline void RelabelType::clear_location() { _impl_.location_ = 0; } inline int32_t RelabelType::_internal_location() const { return _impl_.location_; } inline int32_t RelabelType::location() const { // @@protoc_insertion_point(field_get:pg_query.RelabelType.location) return _internal_location(); } inline void RelabelType::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void RelabelType::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.RelabelType.location) } // ------------------------------------------------------------------- // CoerceViaIO // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool CoerceViaIO::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool CoerceViaIO::has_xpr() const { return _internal_has_xpr(); } inline void CoerceViaIO::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& CoerceViaIO::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& CoerceViaIO::xpr() const { // @@protoc_insertion_point(field_get:pg_query.CoerceViaIO.xpr) return _internal_xpr(); } inline void CoerceViaIO::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CoerceViaIO.xpr) } inline ::pg_query::Node* CoerceViaIO::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* CoerceViaIO::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.CoerceViaIO.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* CoerceViaIO::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* CoerceViaIO::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.CoerceViaIO.xpr) } // .pg_query.Node arg = 2 [json_name = "arg"]; inline bool CoerceViaIO::_internal_has_arg() const { return this != internal_default_instance() && _impl_.arg_ != nullptr; } inline bool CoerceViaIO::has_arg() const { return _internal_has_arg(); } inline void CoerceViaIO::clear_arg() { if (GetArenaForAllocation() == nullptr && _impl_.arg_ != nullptr) { delete _impl_.arg_; } _impl_.arg_ = nullptr; } inline const ::pg_query::Node& CoerceViaIO::_internal_arg() const { const ::pg_query::Node* p = _impl_.arg_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& CoerceViaIO::arg() const { // @@protoc_insertion_point(field_get:pg_query.CoerceViaIO.arg) return _internal_arg(); } inline void CoerceViaIO::unsafe_arena_set_allocated_arg( ::pg_query::Node* arg) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.arg_); } _impl_.arg_ = arg; if (arg) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CoerceViaIO.arg) } inline ::pg_query::Node* CoerceViaIO::release_arg() { ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* CoerceViaIO::unsafe_arena_release_arg() { // @@protoc_insertion_point(field_release:pg_query.CoerceViaIO.arg) ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; return temp; } inline ::pg_query::Node* CoerceViaIO::_internal_mutable_arg() { if (_impl_.arg_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.arg_ = p; } return _impl_.arg_; } inline ::pg_query::Node* CoerceViaIO::mutable_arg() { ::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* arg) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.arg_; } if (arg) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(arg); if (message_arena != submessage_arena) { arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, arg, submessage_arena); } } else { } _impl_.arg_ = arg; // @@protoc_insertion_point(field_set_allocated:pg_query.CoerceViaIO.arg) } // uint32 resulttype = 3 [json_name = "resulttype"]; inline void CoerceViaIO::clear_resulttype() { _impl_.resulttype_ = 0u; } inline uint32_t CoerceViaIO::_internal_resulttype() const { return _impl_.resulttype_; } inline uint32_t CoerceViaIO::resulttype() const { // @@protoc_insertion_point(field_get:pg_query.CoerceViaIO.resulttype) return _internal_resulttype(); } inline void CoerceViaIO::_internal_set_resulttype(uint32_t value) { _impl_.resulttype_ = value; } inline void CoerceViaIO::set_resulttype(uint32_t value) { _internal_set_resulttype(value); // @@protoc_insertion_point(field_set:pg_query.CoerceViaIO.resulttype) } // uint32 resultcollid = 4 [json_name = "resultcollid"]; inline void CoerceViaIO::clear_resultcollid() { _impl_.resultcollid_ = 0u; } inline uint32_t CoerceViaIO::_internal_resultcollid() const { return _impl_.resultcollid_; } inline uint32_t CoerceViaIO::resultcollid() const { // @@protoc_insertion_point(field_get:pg_query.CoerceViaIO.resultcollid) return _internal_resultcollid(); } inline void CoerceViaIO::_internal_set_resultcollid(uint32_t value) { _impl_.resultcollid_ = value; } inline void CoerceViaIO::set_resultcollid(uint32_t value) { _internal_set_resultcollid(value); // @@protoc_insertion_point(field_set:pg_query.CoerceViaIO.resultcollid) } // .pg_query.CoercionForm coerceformat = 5 [json_name = "coerceformat"]; inline void CoerceViaIO::clear_coerceformat() { _impl_.coerceformat_ = 0; } inline ::pg_query::CoercionForm CoerceViaIO::_internal_coerceformat() const { return static_cast< ::pg_query::CoercionForm >(_impl_.coerceformat_); } inline ::pg_query::CoercionForm CoerceViaIO::coerceformat() const { // @@protoc_insertion_point(field_get:pg_query.CoerceViaIO.coerceformat) return _internal_coerceformat(); } inline void CoerceViaIO::_internal_set_coerceformat(::pg_query::CoercionForm value) { _impl_.coerceformat_ = value; } inline void CoerceViaIO::set_coerceformat(::pg_query::CoercionForm value) { _internal_set_coerceformat(value); // @@protoc_insertion_point(field_set:pg_query.CoerceViaIO.coerceformat) } // int32 location = 6 [json_name = "location"]; inline void CoerceViaIO::clear_location() { _impl_.location_ = 0; } inline int32_t CoerceViaIO::_internal_location() const { return _impl_.location_; } inline int32_t CoerceViaIO::location() const { // @@protoc_insertion_point(field_get:pg_query.CoerceViaIO.location) return _internal_location(); } inline void CoerceViaIO::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void CoerceViaIO::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.CoerceViaIO.location) } // ------------------------------------------------------------------- // ArrayCoerceExpr // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool ArrayCoerceExpr::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool ArrayCoerceExpr::has_xpr() const { return _internal_has_xpr(); } inline void ArrayCoerceExpr::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& ArrayCoerceExpr::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& ArrayCoerceExpr::xpr() const { // @@protoc_insertion_point(field_get:pg_query.ArrayCoerceExpr.xpr) return _internal_xpr(); } inline void ArrayCoerceExpr::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ArrayCoerceExpr.xpr) } inline ::pg_query::Node* ArrayCoerceExpr::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* ArrayCoerceExpr::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.ArrayCoerceExpr.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* ArrayCoerceExpr::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* ArrayCoerceExpr::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.ArrayCoerceExpr.xpr) } // .pg_query.Node arg = 2 [json_name = "arg"]; inline bool ArrayCoerceExpr::_internal_has_arg() const { return this != internal_default_instance() && _impl_.arg_ != nullptr; } inline bool ArrayCoerceExpr::has_arg() const { return _internal_has_arg(); } inline void ArrayCoerceExpr::clear_arg() { if (GetArenaForAllocation() == nullptr && _impl_.arg_ != nullptr) { delete _impl_.arg_; } _impl_.arg_ = nullptr; } inline const ::pg_query::Node& ArrayCoerceExpr::_internal_arg() const { const ::pg_query::Node* p = _impl_.arg_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& ArrayCoerceExpr::arg() const { // @@protoc_insertion_point(field_get:pg_query.ArrayCoerceExpr.arg) return _internal_arg(); } inline void ArrayCoerceExpr::unsafe_arena_set_allocated_arg( ::pg_query::Node* arg) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.arg_); } _impl_.arg_ = arg; if (arg) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ArrayCoerceExpr.arg) } inline ::pg_query::Node* ArrayCoerceExpr::release_arg() { ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* ArrayCoerceExpr::unsafe_arena_release_arg() { // @@protoc_insertion_point(field_release:pg_query.ArrayCoerceExpr.arg) ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; return temp; } inline ::pg_query::Node* ArrayCoerceExpr::_internal_mutable_arg() { if (_impl_.arg_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.arg_ = p; } return _impl_.arg_; } inline ::pg_query::Node* ArrayCoerceExpr::mutable_arg() { ::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* arg) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.arg_; } if (arg) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(arg); if (message_arena != submessage_arena) { arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, arg, submessage_arena); } } else { } _impl_.arg_ = arg; // @@protoc_insertion_point(field_set_allocated:pg_query.ArrayCoerceExpr.arg) } // .pg_query.Node elemexpr = 3 [json_name = "elemexpr"]; inline bool ArrayCoerceExpr::_internal_has_elemexpr() const { return this != internal_default_instance() && _impl_.elemexpr_ != nullptr; } inline bool ArrayCoerceExpr::has_elemexpr() const { return _internal_has_elemexpr(); } inline void ArrayCoerceExpr::clear_elemexpr() { if (GetArenaForAllocation() == nullptr && _impl_.elemexpr_ != nullptr) { delete _impl_.elemexpr_; } _impl_.elemexpr_ = nullptr; } inline const ::pg_query::Node& ArrayCoerceExpr::_internal_elemexpr() const { const ::pg_query::Node* p = _impl_.elemexpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& ArrayCoerceExpr::elemexpr() const { // @@protoc_insertion_point(field_get:pg_query.ArrayCoerceExpr.elemexpr) return _internal_elemexpr(); } inline void ArrayCoerceExpr::unsafe_arena_set_allocated_elemexpr( ::pg_query::Node* elemexpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.elemexpr_); } _impl_.elemexpr_ = elemexpr; if (elemexpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ArrayCoerceExpr.elemexpr) } inline ::pg_query::Node* ArrayCoerceExpr::release_elemexpr() { ::pg_query::Node* temp = _impl_.elemexpr_; _impl_.elemexpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* ArrayCoerceExpr::unsafe_arena_release_elemexpr() { // @@protoc_insertion_point(field_release:pg_query.ArrayCoerceExpr.elemexpr) ::pg_query::Node* temp = _impl_.elemexpr_; _impl_.elemexpr_ = nullptr; return temp; } inline ::pg_query::Node* ArrayCoerceExpr::_internal_mutable_elemexpr() { if (_impl_.elemexpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.elemexpr_ = p; } return _impl_.elemexpr_; } inline ::pg_query::Node* ArrayCoerceExpr::mutable_elemexpr() { ::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* elemexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.elemexpr_; } if (elemexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(elemexpr); if (message_arena != submessage_arena) { elemexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, elemexpr, submessage_arena); } } else { } _impl_.elemexpr_ = elemexpr; // @@protoc_insertion_point(field_set_allocated:pg_query.ArrayCoerceExpr.elemexpr) } // uint32 resulttype = 4 [json_name = "resulttype"]; inline void ArrayCoerceExpr::clear_resulttype() { _impl_.resulttype_ = 0u; } inline uint32_t ArrayCoerceExpr::_internal_resulttype() const { return _impl_.resulttype_; } inline uint32_t ArrayCoerceExpr::resulttype() const { // @@protoc_insertion_point(field_get:pg_query.ArrayCoerceExpr.resulttype) return _internal_resulttype(); } inline void ArrayCoerceExpr::_internal_set_resulttype(uint32_t value) { _impl_.resulttype_ = value; } inline void ArrayCoerceExpr::set_resulttype(uint32_t value) { _internal_set_resulttype(value); // @@protoc_insertion_point(field_set:pg_query.ArrayCoerceExpr.resulttype) } // int32 resulttypmod = 5 [json_name = "resulttypmod"]; inline void ArrayCoerceExpr::clear_resulttypmod() { _impl_.resulttypmod_ = 0; } inline int32_t ArrayCoerceExpr::_internal_resulttypmod() const { return _impl_.resulttypmod_; } inline int32_t ArrayCoerceExpr::resulttypmod() const { // @@protoc_insertion_point(field_get:pg_query.ArrayCoerceExpr.resulttypmod) return _internal_resulttypmod(); } inline void ArrayCoerceExpr::_internal_set_resulttypmod(int32_t value) { _impl_.resulttypmod_ = value; } inline void ArrayCoerceExpr::set_resulttypmod(int32_t value) { _internal_set_resulttypmod(value); // @@protoc_insertion_point(field_set:pg_query.ArrayCoerceExpr.resulttypmod) } // uint32 resultcollid = 6 [json_name = "resultcollid"]; inline void ArrayCoerceExpr::clear_resultcollid() { _impl_.resultcollid_ = 0u; } inline uint32_t ArrayCoerceExpr::_internal_resultcollid() const { return _impl_.resultcollid_; } inline uint32_t ArrayCoerceExpr::resultcollid() const { // @@protoc_insertion_point(field_get:pg_query.ArrayCoerceExpr.resultcollid) return _internal_resultcollid(); } inline void ArrayCoerceExpr::_internal_set_resultcollid(uint32_t value) { _impl_.resultcollid_ = value; } inline void ArrayCoerceExpr::set_resultcollid(uint32_t value) { _internal_set_resultcollid(value); // @@protoc_insertion_point(field_set:pg_query.ArrayCoerceExpr.resultcollid) } // .pg_query.CoercionForm coerceformat = 7 [json_name = "coerceformat"]; inline void ArrayCoerceExpr::clear_coerceformat() { _impl_.coerceformat_ = 0; } inline ::pg_query::CoercionForm ArrayCoerceExpr::_internal_coerceformat() const { return static_cast< ::pg_query::CoercionForm >(_impl_.coerceformat_); } inline ::pg_query::CoercionForm ArrayCoerceExpr::coerceformat() const { // @@protoc_insertion_point(field_get:pg_query.ArrayCoerceExpr.coerceformat) return _internal_coerceformat(); } inline void ArrayCoerceExpr::_internal_set_coerceformat(::pg_query::CoercionForm value) { _impl_.coerceformat_ = value; } inline void ArrayCoerceExpr::set_coerceformat(::pg_query::CoercionForm value) { _internal_set_coerceformat(value); // @@protoc_insertion_point(field_set:pg_query.ArrayCoerceExpr.coerceformat) } // int32 location = 8 [json_name = "location"]; inline void ArrayCoerceExpr::clear_location() { _impl_.location_ = 0; } inline int32_t ArrayCoerceExpr::_internal_location() const { return _impl_.location_; } inline int32_t ArrayCoerceExpr::location() const { // @@protoc_insertion_point(field_get:pg_query.ArrayCoerceExpr.location) return _internal_location(); } inline void ArrayCoerceExpr::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void ArrayCoerceExpr::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.ArrayCoerceExpr.location) } // ------------------------------------------------------------------- // ConvertRowtypeExpr // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool ConvertRowtypeExpr::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool ConvertRowtypeExpr::has_xpr() const { return _internal_has_xpr(); } inline void ConvertRowtypeExpr::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& ConvertRowtypeExpr::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& ConvertRowtypeExpr::xpr() const { // @@protoc_insertion_point(field_get:pg_query.ConvertRowtypeExpr.xpr) return _internal_xpr(); } inline void ConvertRowtypeExpr::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ConvertRowtypeExpr.xpr) } inline ::pg_query::Node* ConvertRowtypeExpr::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* ConvertRowtypeExpr::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.ConvertRowtypeExpr.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* ConvertRowtypeExpr::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* ConvertRowtypeExpr::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.ConvertRowtypeExpr.xpr) } // .pg_query.Node arg = 2 [json_name = "arg"]; inline bool ConvertRowtypeExpr::_internal_has_arg() const { return this != internal_default_instance() && _impl_.arg_ != nullptr; } inline bool ConvertRowtypeExpr::has_arg() const { return _internal_has_arg(); } inline void ConvertRowtypeExpr::clear_arg() { if (GetArenaForAllocation() == nullptr && _impl_.arg_ != nullptr) { delete _impl_.arg_; } _impl_.arg_ = nullptr; } inline const ::pg_query::Node& ConvertRowtypeExpr::_internal_arg() const { const ::pg_query::Node* p = _impl_.arg_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& ConvertRowtypeExpr::arg() const { // @@protoc_insertion_point(field_get:pg_query.ConvertRowtypeExpr.arg) return _internal_arg(); } inline void ConvertRowtypeExpr::unsafe_arena_set_allocated_arg( ::pg_query::Node* arg) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.arg_); } _impl_.arg_ = arg; if (arg) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ConvertRowtypeExpr.arg) } inline ::pg_query::Node* ConvertRowtypeExpr::release_arg() { ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* ConvertRowtypeExpr::unsafe_arena_release_arg() { // @@protoc_insertion_point(field_release:pg_query.ConvertRowtypeExpr.arg) ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; return temp; } inline ::pg_query::Node* ConvertRowtypeExpr::_internal_mutable_arg() { if (_impl_.arg_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.arg_ = p; } return _impl_.arg_; } inline ::pg_query::Node* ConvertRowtypeExpr::mutable_arg() { ::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* arg) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.arg_; } if (arg) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(arg); if (message_arena != submessage_arena) { arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, arg, submessage_arena); } } else { } _impl_.arg_ = arg; // @@protoc_insertion_point(field_set_allocated:pg_query.ConvertRowtypeExpr.arg) } // uint32 resulttype = 3 [json_name = "resulttype"]; inline void ConvertRowtypeExpr::clear_resulttype() { _impl_.resulttype_ = 0u; } inline uint32_t ConvertRowtypeExpr::_internal_resulttype() const { return _impl_.resulttype_; } inline uint32_t ConvertRowtypeExpr::resulttype() const { // @@protoc_insertion_point(field_get:pg_query.ConvertRowtypeExpr.resulttype) return _internal_resulttype(); } inline void ConvertRowtypeExpr::_internal_set_resulttype(uint32_t value) { _impl_.resulttype_ = value; } inline void ConvertRowtypeExpr::set_resulttype(uint32_t value) { _internal_set_resulttype(value); // @@protoc_insertion_point(field_set:pg_query.ConvertRowtypeExpr.resulttype) } // .pg_query.CoercionForm convertformat = 4 [json_name = "convertformat"]; inline void ConvertRowtypeExpr::clear_convertformat() { _impl_.convertformat_ = 0; } inline ::pg_query::CoercionForm ConvertRowtypeExpr::_internal_convertformat() const { return static_cast< ::pg_query::CoercionForm >(_impl_.convertformat_); } inline ::pg_query::CoercionForm ConvertRowtypeExpr::convertformat() const { // @@protoc_insertion_point(field_get:pg_query.ConvertRowtypeExpr.convertformat) return _internal_convertformat(); } inline void ConvertRowtypeExpr::_internal_set_convertformat(::pg_query::CoercionForm value) { _impl_.convertformat_ = value; } inline void ConvertRowtypeExpr::set_convertformat(::pg_query::CoercionForm value) { _internal_set_convertformat(value); // @@protoc_insertion_point(field_set:pg_query.ConvertRowtypeExpr.convertformat) } // int32 location = 5 [json_name = "location"]; inline void ConvertRowtypeExpr::clear_location() { _impl_.location_ = 0; } inline int32_t ConvertRowtypeExpr::_internal_location() const { return _impl_.location_; } inline int32_t ConvertRowtypeExpr::location() const { // @@protoc_insertion_point(field_get:pg_query.ConvertRowtypeExpr.location) return _internal_location(); } inline void ConvertRowtypeExpr::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void ConvertRowtypeExpr::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.ConvertRowtypeExpr.location) } // ------------------------------------------------------------------- // CollateExpr // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool CollateExpr::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool CollateExpr::has_xpr() const { return _internal_has_xpr(); } inline void CollateExpr::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& CollateExpr::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& CollateExpr::xpr() const { // @@protoc_insertion_point(field_get:pg_query.CollateExpr.xpr) return _internal_xpr(); } inline void CollateExpr::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CollateExpr.xpr) } inline ::pg_query::Node* CollateExpr::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* CollateExpr::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.CollateExpr.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* CollateExpr::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* CollateExpr::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.CollateExpr.xpr) } // .pg_query.Node arg = 2 [json_name = "arg"]; inline bool CollateExpr::_internal_has_arg() const { return this != internal_default_instance() && _impl_.arg_ != nullptr; } inline bool CollateExpr::has_arg() const { return _internal_has_arg(); } inline void CollateExpr::clear_arg() { if (GetArenaForAllocation() == nullptr && _impl_.arg_ != nullptr) { delete _impl_.arg_; } _impl_.arg_ = nullptr; } inline const ::pg_query::Node& CollateExpr::_internal_arg() const { const ::pg_query::Node* p = _impl_.arg_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& CollateExpr::arg() const { // @@protoc_insertion_point(field_get:pg_query.CollateExpr.arg) return _internal_arg(); } inline void CollateExpr::unsafe_arena_set_allocated_arg( ::pg_query::Node* arg) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.arg_); } _impl_.arg_ = arg; if (arg) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CollateExpr.arg) } inline ::pg_query::Node* CollateExpr::release_arg() { ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* CollateExpr::unsafe_arena_release_arg() { // @@protoc_insertion_point(field_release:pg_query.CollateExpr.arg) ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; return temp; } inline ::pg_query::Node* CollateExpr::_internal_mutable_arg() { if (_impl_.arg_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.arg_ = p; } return _impl_.arg_; } inline ::pg_query::Node* CollateExpr::mutable_arg() { ::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* arg) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.arg_; } if (arg) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(arg); if (message_arena != submessage_arena) { arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, arg, submessage_arena); } } else { } _impl_.arg_ = arg; // @@protoc_insertion_point(field_set_allocated:pg_query.CollateExpr.arg) } // uint32 coll_oid = 3 [json_name = "collOid"]; inline void CollateExpr::clear_coll_oid() { _impl_.coll_oid_ = 0u; } inline uint32_t CollateExpr::_internal_coll_oid() const { return _impl_.coll_oid_; } inline uint32_t CollateExpr::coll_oid() const { // @@protoc_insertion_point(field_get:pg_query.CollateExpr.coll_oid) return _internal_coll_oid(); } inline void CollateExpr::_internal_set_coll_oid(uint32_t value) { _impl_.coll_oid_ = value; } inline void CollateExpr::set_coll_oid(uint32_t value) { _internal_set_coll_oid(value); // @@protoc_insertion_point(field_set:pg_query.CollateExpr.coll_oid) } // int32 location = 4 [json_name = "location"]; inline void CollateExpr::clear_location() { _impl_.location_ = 0; } inline int32_t CollateExpr::_internal_location() const { return _impl_.location_; } inline int32_t CollateExpr::location() const { // @@protoc_insertion_point(field_get:pg_query.CollateExpr.location) return _internal_location(); } inline void CollateExpr::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void CollateExpr::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.CollateExpr.location) } // ------------------------------------------------------------------- // CaseExpr // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool CaseExpr::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool CaseExpr::has_xpr() const { return _internal_has_xpr(); } inline void CaseExpr::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& CaseExpr::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& CaseExpr::xpr() const { // @@protoc_insertion_point(field_get:pg_query.CaseExpr.xpr) return _internal_xpr(); } inline void CaseExpr::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CaseExpr.xpr) } inline ::pg_query::Node* CaseExpr::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* CaseExpr::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.CaseExpr.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* CaseExpr::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* CaseExpr::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.CaseExpr.xpr) } // uint32 casetype = 2 [json_name = "casetype"]; inline void CaseExpr::clear_casetype() { _impl_.casetype_ = 0u; } inline uint32_t CaseExpr::_internal_casetype() const { return _impl_.casetype_; } inline uint32_t CaseExpr::casetype() const { // @@protoc_insertion_point(field_get:pg_query.CaseExpr.casetype) return _internal_casetype(); } inline void CaseExpr::_internal_set_casetype(uint32_t value) { _impl_.casetype_ = value; } inline void CaseExpr::set_casetype(uint32_t value) { _internal_set_casetype(value); // @@protoc_insertion_point(field_set:pg_query.CaseExpr.casetype) } // uint32 casecollid = 3 [json_name = "casecollid"]; inline void CaseExpr::clear_casecollid() { _impl_.casecollid_ = 0u; } inline uint32_t CaseExpr::_internal_casecollid() const { return _impl_.casecollid_; } inline uint32_t CaseExpr::casecollid() const { // @@protoc_insertion_point(field_get:pg_query.CaseExpr.casecollid) return _internal_casecollid(); } inline void CaseExpr::_internal_set_casecollid(uint32_t value) { _impl_.casecollid_ = value; } inline void CaseExpr::set_casecollid(uint32_t value) { _internal_set_casecollid(value); // @@protoc_insertion_point(field_set:pg_query.CaseExpr.casecollid) } // .pg_query.Node arg = 4 [json_name = "arg"]; inline bool CaseExpr::_internal_has_arg() const { return this != internal_default_instance() && _impl_.arg_ != nullptr; } inline bool CaseExpr::has_arg() const { return _internal_has_arg(); } inline void CaseExpr::clear_arg() { if (GetArenaForAllocation() == nullptr && _impl_.arg_ != nullptr) { delete _impl_.arg_; } _impl_.arg_ = nullptr; } inline const ::pg_query::Node& CaseExpr::_internal_arg() const { const ::pg_query::Node* p = _impl_.arg_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& CaseExpr::arg() const { // @@protoc_insertion_point(field_get:pg_query.CaseExpr.arg) return _internal_arg(); } inline void CaseExpr::unsafe_arena_set_allocated_arg( ::pg_query::Node* arg) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.arg_); } _impl_.arg_ = arg; if (arg) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CaseExpr.arg) } inline ::pg_query::Node* CaseExpr::release_arg() { ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* CaseExpr::unsafe_arena_release_arg() { // @@protoc_insertion_point(field_release:pg_query.CaseExpr.arg) ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; return temp; } inline ::pg_query::Node* CaseExpr::_internal_mutable_arg() { if (_impl_.arg_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.arg_ = p; } return _impl_.arg_; } inline ::pg_query::Node* CaseExpr::mutable_arg() { ::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* arg) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.arg_; } if (arg) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(arg); if (message_arena != submessage_arena) { arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, arg, submessage_arena); } } else { } _impl_.arg_ = arg; // @@protoc_insertion_point(field_set_allocated:pg_query.CaseExpr.arg) } // repeated .pg_query.Node args = 5 [json_name = "args"]; inline int CaseExpr::_internal_args_size() const { return _impl_.args_.size(); } inline int CaseExpr::args_size() const { return _internal_args_size(); } inline void CaseExpr::clear_args() { _impl_.args_.Clear(); } inline ::pg_query::Node* CaseExpr::mutable_args(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CaseExpr.args) return _impl_.args_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CaseExpr::mutable_args() { // @@protoc_insertion_point(field_mutable_list:pg_query.CaseExpr.args) return &_impl_.args_; } inline const ::pg_query::Node& CaseExpr::_internal_args(int index) const { return _impl_.args_.Get(index); } inline const ::pg_query::Node& CaseExpr::args(int index) const { // @@protoc_insertion_point(field_get:pg_query.CaseExpr.args) return _internal_args(index); } inline ::pg_query::Node* CaseExpr::_internal_add_args() { return _impl_.args_.Add(); } inline ::pg_query::Node* CaseExpr::add_args() { ::pg_query::Node* _add = _internal_add_args(); // @@protoc_insertion_point(field_add:pg_query.CaseExpr.args) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CaseExpr::args() const { // @@protoc_insertion_point(field_list:pg_query.CaseExpr.args) return _impl_.args_; } // .pg_query.Node defresult = 6 [json_name = "defresult"]; inline bool CaseExpr::_internal_has_defresult() const { return this != internal_default_instance() && _impl_.defresult_ != nullptr; } inline bool CaseExpr::has_defresult() const { return _internal_has_defresult(); } inline void CaseExpr::clear_defresult() { if (GetArenaForAllocation() == nullptr && _impl_.defresult_ != nullptr) { delete _impl_.defresult_; } _impl_.defresult_ = nullptr; } inline const ::pg_query::Node& CaseExpr::_internal_defresult() const { const ::pg_query::Node* p = _impl_.defresult_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& CaseExpr::defresult() const { // @@protoc_insertion_point(field_get:pg_query.CaseExpr.defresult) return _internal_defresult(); } inline void CaseExpr::unsafe_arena_set_allocated_defresult( ::pg_query::Node* defresult) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.defresult_); } _impl_.defresult_ = defresult; if (defresult) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CaseExpr.defresult) } inline ::pg_query::Node* CaseExpr::release_defresult() { ::pg_query::Node* temp = _impl_.defresult_; _impl_.defresult_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* CaseExpr::unsafe_arena_release_defresult() { // @@protoc_insertion_point(field_release:pg_query.CaseExpr.defresult) ::pg_query::Node* temp = _impl_.defresult_; _impl_.defresult_ = nullptr; return temp; } inline ::pg_query::Node* CaseExpr::_internal_mutable_defresult() { if (_impl_.defresult_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.defresult_ = p; } return _impl_.defresult_; } inline ::pg_query::Node* CaseExpr::mutable_defresult() { ::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* defresult) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.defresult_; } if (defresult) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(defresult); if (message_arena != submessage_arena) { defresult = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, defresult, submessage_arena); } } else { } _impl_.defresult_ = defresult; // @@protoc_insertion_point(field_set_allocated:pg_query.CaseExpr.defresult) } // int32 location = 7 [json_name = "location"]; inline void CaseExpr::clear_location() { _impl_.location_ = 0; } inline int32_t CaseExpr::_internal_location() const { return _impl_.location_; } inline int32_t CaseExpr::location() const { // @@protoc_insertion_point(field_get:pg_query.CaseExpr.location) return _internal_location(); } inline void CaseExpr::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void CaseExpr::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.CaseExpr.location) } // ------------------------------------------------------------------- // CaseWhen // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool CaseWhen::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool CaseWhen::has_xpr() const { return _internal_has_xpr(); } inline void CaseWhen::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& CaseWhen::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& CaseWhen::xpr() const { // @@protoc_insertion_point(field_get:pg_query.CaseWhen.xpr) return _internal_xpr(); } inline void CaseWhen::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CaseWhen.xpr) } inline ::pg_query::Node* CaseWhen::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* CaseWhen::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.CaseWhen.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* CaseWhen::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* CaseWhen::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.CaseWhen.xpr) } // .pg_query.Node expr = 2 [json_name = "expr"]; inline bool CaseWhen::_internal_has_expr() const { return this != internal_default_instance() && _impl_.expr_ != nullptr; } inline bool CaseWhen::has_expr() const { return _internal_has_expr(); } inline void CaseWhen::clear_expr() { if (GetArenaForAllocation() == nullptr && _impl_.expr_ != nullptr) { delete _impl_.expr_; } _impl_.expr_ = nullptr; } inline const ::pg_query::Node& CaseWhen::_internal_expr() const { const ::pg_query::Node* p = _impl_.expr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& CaseWhen::expr() const { // @@protoc_insertion_point(field_get:pg_query.CaseWhen.expr) return _internal_expr(); } inline void CaseWhen::unsafe_arena_set_allocated_expr( ::pg_query::Node* expr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.expr_); } _impl_.expr_ = expr; if (expr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CaseWhen.expr) } inline ::pg_query::Node* CaseWhen::release_expr() { ::pg_query::Node* temp = _impl_.expr_; _impl_.expr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* CaseWhen::unsafe_arena_release_expr() { // @@protoc_insertion_point(field_release:pg_query.CaseWhen.expr) ::pg_query::Node* temp = _impl_.expr_; _impl_.expr_ = nullptr; return temp; } inline ::pg_query::Node* CaseWhen::_internal_mutable_expr() { if (_impl_.expr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.expr_ = p; } return _impl_.expr_; } inline ::pg_query::Node* CaseWhen::mutable_expr() { ::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* expr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.expr_; } if (expr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(expr); if (message_arena != submessage_arena) { expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, expr, submessage_arena); } } else { } _impl_.expr_ = expr; // @@protoc_insertion_point(field_set_allocated:pg_query.CaseWhen.expr) } // .pg_query.Node result = 3 [json_name = "result"]; inline bool CaseWhen::_internal_has_result() const { return this != internal_default_instance() && _impl_.result_ != nullptr; } inline bool CaseWhen::has_result() const { return _internal_has_result(); } inline void CaseWhen::clear_result() { if (GetArenaForAllocation() == nullptr && _impl_.result_ != nullptr) { delete _impl_.result_; } _impl_.result_ = nullptr; } inline const ::pg_query::Node& CaseWhen::_internal_result() const { const ::pg_query::Node* p = _impl_.result_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& CaseWhen::result() const { // @@protoc_insertion_point(field_get:pg_query.CaseWhen.result) return _internal_result(); } inline void CaseWhen::unsafe_arena_set_allocated_result( ::pg_query::Node* result) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.result_); } _impl_.result_ = result; if (result) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CaseWhen.result) } inline ::pg_query::Node* CaseWhen::release_result() { ::pg_query::Node* temp = _impl_.result_; _impl_.result_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* CaseWhen::unsafe_arena_release_result() { // @@protoc_insertion_point(field_release:pg_query.CaseWhen.result) ::pg_query::Node* temp = _impl_.result_; _impl_.result_ = nullptr; return temp; } inline ::pg_query::Node* CaseWhen::_internal_mutable_result() { if (_impl_.result_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.result_ = p; } return _impl_.result_; } inline ::pg_query::Node* CaseWhen::mutable_result() { ::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* result) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.result_; } if (result) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(result); if (message_arena != submessage_arena) { result = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, result, submessage_arena); } } else { } _impl_.result_ = result; // @@protoc_insertion_point(field_set_allocated:pg_query.CaseWhen.result) } // int32 location = 4 [json_name = "location"]; inline void CaseWhen::clear_location() { _impl_.location_ = 0; } inline int32_t CaseWhen::_internal_location() const { return _impl_.location_; } inline int32_t CaseWhen::location() const { // @@protoc_insertion_point(field_get:pg_query.CaseWhen.location) return _internal_location(); } inline void CaseWhen::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void CaseWhen::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.CaseWhen.location) } // ------------------------------------------------------------------- // CaseTestExpr // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool CaseTestExpr::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool CaseTestExpr::has_xpr() const { return _internal_has_xpr(); } inline void CaseTestExpr::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& CaseTestExpr::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& CaseTestExpr::xpr() const { // @@protoc_insertion_point(field_get:pg_query.CaseTestExpr.xpr) return _internal_xpr(); } inline void CaseTestExpr::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CaseTestExpr.xpr) } inline ::pg_query::Node* CaseTestExpr::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* CaseTestExpr::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.CaseTestExpr.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* CaseTestExpr::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* CaseTestExpr::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.CaseTestExpr.xpr) } // uint32 type_id = 2 [json_name = "typeId"]; inline void CaseTestExpr::clear_type_id() { _impl_.type_id_ = 0u; } inline uint32_t CaseTestExpr::_internal_type_id() const { return _impl_.type_id_; } inline uint32_t CaseTestExpr::type_id() const { // @@protoc_insertion_point(field_get:pg_query.CaseTestExpr.type_id) return _internal_type_id(); } inline void CaseTestExpr::_internal_set_type_id(uint32_t value) { _impl_.type_id_ = value; } inline void CaseTestExpr::set_type_id(uint32_t value) { _internal_set_type_id(value); // @@protoc_insertion_point(field_set:pg_query.CaseTestExpr.type_id) } // int32 type_mod = 3 [json_name = "typeMod"]; inline void CaseTestExpr::clear_type_mod() { _impl_.type_mod_ = 0; } inline int32_t CaseTestExpr::_internal_type_mod() const { return _impl_.type_mod_; } inline int32_t CaseTestExpr::type_mod() const { // @@protoc_insertion_point(field_get:pg_query.CaseTestExpr.type_mod) return _internal_type_mod(); } inline void CaseTestExpr::_internal_set_type_mod(int32_t value) { _impl_.type_mod_ = value; } inline void CaseTestExpr::set_type_mod(int32_t value) { _internal_set_type_mod(value); // @@protoc_insertion_point(field_set:pg_query.CaseTestExpr.type_mod) } // uint32 collation = 4 [json_name = "collation"]; inline void CaseTestExpr::clear_collation() { _impl_.collation_ = 0u; } inline uint32_t CaseTestExpr::_internal_collation() const { return _impl_.collation_; } inline uint32_t CaseTestExpr::collation() const { // @@protoc_insertion_point(field_get:pg_query.CaseTestExpr.collation) return _internal_collation(); } inline void CaseTestExpr::_internal_set_collation(uint32_t value) { _impl_.collation_ = value; } inline void CaseTestExpr::set_collation(uint32_t value) { _internal_set_collation(value); // @@protoc_insertion_point(field_set:pg_query.CaseTestExpr.collation) } // ------------------------------------------------------------------- // ArrayExpr // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool ArrayExpr::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool ArrayExpr::has_xpr() const { return _internal_has_xpr(); } inline void ArrayExpr::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& ArrayExpr::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& ArrayExpr::xpr() const { // @@protoc_insertion_point(field_get:pg_query.ArrayExpr.xpr) return _internal_xpr(); } inline void ArrayExpr::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ArrayExpr.xpr) } inline ::pg_query::Node* ArrayExpr::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* ArrayExpr::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.ArrayExpr.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* ArrayExpr::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* ArrayExpr::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.ArrayExpr.xpr) } // uint32 array_typeid = 2 [json_name = "array_typeid"]; inline void ArrayExpr::clear_array_typeid() { _impl_.array_typeid_ = 0u; } inline uint32_t ArrayExpr::_internal_array_typeid() const { return _impl_.array_typeid_; } inline uint32_t ArrayExpr::array_typeid() const { // @@protoc_insertion_point(field_get:pg_query.ArrayExpr.array_typeid) return _internal_array_typeid(); } inline void ArrayExpr::_internal_set_array_typeid(uint32_t value) { _impl_.array_typeid_ = value; } inline void ArrayExpr::set_array_typeid(uint32_t value) { _internal_set_array_typeid(value); // @@protoc_insertion_point(field_set:pg_query.ArrayExpr.array_typeid) } // uint32 array_collid = 3 [json_name = "array_collid"]; inline void ArrayExpr::clear_array_collid() { _impl_.array_collid_ = 0u; } inline uint32_t ArrayExpr::_internal_array_collid() const { return _impl_.array_collid_; } inline uint32_t ArrayExpr::array_collid() const { // @@protoc_insertion_point(field_get:pg_query.ArrayExpr.array_collid) return _internal_array_collid(); } inline void ArrayExpr::_internal_set_array_collid(uint32_t value) { _impl_.array_collid_ = value; } inline void ArrayExpr::set_array_collid(uint32_t value) { _internal_set_array_collid(value); // @@protoc_insertion_point(field_set:pg_query.ArrayExpr.array_collid) } // uint32 element_typeid = 4 [json_name = "element_typeid"]; inline void ArrayExpr::clear_element_typeid() { _impl_.element_typeid_ = 0u; } inline uint32_t ArrayExpr::_internal_element_typeid() const { return _impl_.element_typeid_; } inline uint32_t ArrayExpr::element_typeid() const { // @@protoc_insertion_point(field_get:pg_query.ArrayExpr.element_typeid) return _internal_element_typeid(); } inline void ArrayExpr::_internal_set_element_typeid(uint32_t value) { _impl_.element_typeid_ = value; } inline void ArrayExpr::set_element_typeid(uint32_t value) { _internal_set_element_typeid(value); // @@protoc_insertion_point(field_set:pg_query.ArrayExpr.element_typeid) } // repeated .pg_query.Node elements = 5 [json_name = "elements"]; inline int ArrayExpr::_internal_elements_size() const { return _impl_.elements_.size(); } inline int ArrayExpr::elements_size() const { return _internal_elements_size(); } inline void ArrayExpr::clear_elements() { _impl_.elements_.Clear(); } inline ::pg_query::Node* ArrayExpr::mutable_elements(int index) { // @@protoc_insertion_point(field_mutable:pg_query.ArrayExpr.elements) return _impl_.elements_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* ArrayExpr::mutable_elements() { // @@protoc_insertion_point(field_mutable_list:pg_query.ArrayExpr.elements) return &_impl_.elements_; } inline const ::pg_query::Node& ArrayExpr::_internal_elements(int index) const { return _impl_.elements_.Get(index); } inline const ::pg_query::Node& ArrayExpr::elements(int index) const { // @@protoc_insertion_point(field_get:pg_query.ArrayExpr.elements) return _internal_elements(index); } inline ::pg_query::Node* ArrayExpr::_internal_add_elements() { return _impl_.elements_.Add(); } inline ::pg_query::Node* ArrayExpr::add_elements() { ::pg_query::Node* _add = _internal_add_elements(); // @@protoc_insertion_point(field_add:pg_query.ArrayExpr.elements) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& ArrayExpr::elements() const { // @@protoc_insertion_point(field_list:pg_query.ArrayExpr.elements) return _impl_.elements_; } // bool multidims = 6 [json_name = "multidims"]; inline void ArrayExpr::clear_multidims() { _impl_.multidims_ = false; } inline bool ArrayExpr::_internal_multidims() const { return _impl_.multidims_; } inline bool ArrayExpr::multidims() const { // @@protoc_insertion_point(field_get:pg_query.ArrayExpr.multidims) return _internal_multidims(); } inline void ArrayExpr::_internal_set_multidims(bool value) { _impl_.multidims_ = value; } inline void ArrayExpr::set_multidims(bool value) { _internal_set_multidims(value); // @@protoc_insertion_point(field_set:pg_query.ArrayExpr.multidims) } // int32 location = 7 [json_name = "location"]; inline void ArrayExpr::clear_location() { _impl_.location_ = 0; } inline int32_t ArrayExpr::_internal_location() const { return _impl_.location_; } inline int32_t ArrayExpr::location() const { // @@protoc_insertion_point(field_get:pg_query.ArrayExpr.location) return _internal_location(); } inline void ArrayExpr::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void ArrayExpr::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.ArrayExpr.location) } // ------------------------------------------------------------------- // RowExpr // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool RowExpr::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool RowExpr::has_xpr() const { return _internal_has_xpr(); } inline void RowExpr::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& RowExpr::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& RowExpr::xpr() const { // @@protoc_insertion_point(field_get:pg_query.RowExpr.xpr) return _internal_xpr(); } inline void RowExpr::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RowExpr.xpr) } inline ::pg_query::Node* RowExpr::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* RowExpr::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.RowExpr.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* RowExpr::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* RowExpr::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.RowExpr.xpr) } // repeated .pg_query.Node args = 2 [json_name = "args"]; inline int RowExpr::_internal_args_size() const { return _impl_.args_.size(); } inline int RowExpr::args_size() const { return _internal_args_size(); } inline void RowExpr::clear_args() { _impl_.args_.Clear(); } inline ::pg_query::Node* RowExpr::mutable_args(int index) { // @@protoc_insertion_point(field_mutable:pg_query.RowExpr.args) return _impl_.args_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* RowExpr::mutable_args() { // @@protoc_insertion_point(field_mutable_list:pg_query.RowExpr.args) return &_impl_.args_; } inline const ::pg_query::Node& RowExpr::_internal_args(int index) const { return _impl_.args_.Get(index); } inline const ::pg_query::Node& RowExpr::args(int index) const { // @@protoc_insertion_point(field_get:pg_query.RowExpr.args) return _internal_args(index); } inline ::pg_query::Node* RowExpr::_internal_add_args() { return _impl_.args_.Add(); } inline ::pg_query::Node* RowExpr::add_args() { ::pg_query::Node* _add = _internal_add_args(); // @@protoc_insertion_point(field_add:pg_query.RowExpr.args) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& RowExpr::args() const { // @@protoc_insertion_point(field_list:pg_query.RowExpr.args) return _impl_.args_; } // uint32 row_typeid = 3 [json_name = "row_typeid"]; inline void RowExpr::clear_row_typeid() { _impl_.row_typeid_ = 0u; } inline uint32_t RowExpr::_internal_row_typeid() const { return _impl_.row_typeid_; } inline uint32_t RowExpr::row_typeid() const { // @@protoc_insertion_point(field_get:pg_query.RowExpr.row_typeid) return _internal_row_typeid(); } inline void RowExpr::_internal_set_row_typeid(uint32_t value) { _impl_.row_typeid_ = value; } inline void RowExpr::set_row_typeid(uint32_t value) { _internal_set_row_typeid(value); // @@protoc_insertion_point(field_set:pg_query.RowExpr.row_typeid) } // .pg_query.CoercionForm row_format = 4 [json_name = "row_format"]; inline void RowExpr::clear_row_format() { _impl_.row_format_ = 0; } inline ::pg_query::CoercionForm RowExpr::_internal_row_format() const { return static_cast< ::pg_query::CoercionForm >(_impl_.row_format_); } inline ::pg_query::CoercionForm RowExpr::row_format() const { // @@protoc_insertion_point(field_get:pg_query.RowExpr.row_format) return _internal_row_format(); } inline void RowExpr::_internal_set_row_format(::pg_query::CoercionForm value) { _impl_.row_format_ = value; } inline void RowExpr::set_row_format(::pg_query::CoercionForm value) { _internal_set_row_format(value); // @@protoc_insertion_point(field_set:pg_query.RowExpr.row_format) } // repeated .pg_query.Node colnames = 5 [json_name = "colnames"]; inline int RowExpr::_internal_colnames_size() const { return _impl_.colnames_.size(); } inline int RowExpr::colnames_size() const { return _internal_colnames_size(); } inline void RowExpr::clear_colnames() { _impl_.colnames_.Clear(); } inline ::pg_query::Node* RowExpr::mutable_colnames(int index) { // @@protoc_insertion_point(field_mutable:pg_query.RowExpr.colnames) return _impl_.colnames_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* RowExpr::mutable_colnames() { // @@protoc_insertion_point(field_mutable_list:pg_query.RowExpr.colnames) return &_impl_.colnames_; } inline const ::pg_query::Node& RowExpr::_internal_colnames(int index) const { return _impl_.colnames_.Get(index); } inline const ::pg_query::Node& RowExpr::colnames(int index) const { // @@protoc_insertion_point(field_get:pg_query.RowExpr.colnames) return _internal_colnames(index); } inline ::pg_query::Node* RowExpr::_internal_add_colnames() { return _impl_.colnames_.Add(); } inline ::pg_query::Node* RowExpr::add_colnames() { ::pg_query::Node* _add = _internal_add_colnames(); // @@protoc_insertion_point(field_add:pg_query.RowExpr.colnames) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& RowExpr::colnames() const { // @@protoc_insertion_point(field_list:pg_query.RowExpr.colnames) return _impl_.colnames_; } // int32 location = 6 [json_name = "location"]; inline void RowExpr::clear_location() { _impl_.location_ = 0; } inline int32_t RowExpr::_internal_location() const { return _impl_.location_; } inline int32_t RowExpr::location() const { // @@protoc_insertion_point(field_get:pg_query.RowExpr.location) return _internal_location(); } inline void RowExpr::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void RowExpr::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.RowExpr.location) } // ------------------------------------------------------------------- // RowCompareExpr // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool RowCompareExpr::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool RowCompareExpr::has_xpr() const { return _internal_has_xpr(); } inline void RowCompareExpr::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& RowCompareExpr::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& RowCompareExpr::xpr() const { // @@protoc_insertion_point(field_get:pg_query.RowCompareExpr.xpr) return _internal_xpr(); } inline void RowCompareExpr::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RowCompareExpr.xpr) } inline ::pg_query::Node* RowCompareExpr::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* RowCompareExpr::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.RowCompareExpr.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* RowCompareExpr::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* RowCompareExpr::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.RowCompareExpr.xpr) } // .pg_query.RowCompareType rctype = 2 [json_name = "rctype"]; inline void RowCompareExpr::clear_rctype() { _impl_.rctype_ = 0; } inline ::pg_query::RowCompareType RowCompareExpr::_internal_rctype() const { return static_cast< ::pg_query::RowCompareType >(_impl_.rctype_); } inline ::pg_query::RowCompareType RowCompareExpr::rctype() const { // @@protoc_insertion_point(field_get:pg_query.RowCompareExpr.rctype) return _internal_rctype(); } inline void RowCompareExpr::_internal_set_rctype(::pg_query::RowCompareType value) { _impl_.rctype_ = value; } inline void RowCompareExpr::set_rctype(::pg_query::RowCompareType value) { _internal_set_rctype(value); // @@protoc_insertion_point(field_set:pg_query.RowCompareExpr.rctype) } // repeated .pg_query.Node opnos = 3 [json_name = "opnos"]; inline int RowCompareExpr::_internal_opnos_size() const { return _impl_.opnos_.size(); } inline int RowCompareExpr::opnos_size() const { return _internal_opnos_size(); } inline void RowCompareExpr::clear_opnos() { _impl_.opnos_.Clear(); } inline ::pg_query::Node* RowCompareExpr::mutable_opnos(int index) { // @@protoc_insertion_point(field_mutable:pg_query.RowCompareExpr.opnos) return _impl_.opnos_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* RowCompareExpr::mutable_opnos() { // @@protoc_insertion_point(field_mutable_list:pg_query.RowCompareExpr.opnos) return &_impl_.opnos_; } inline const ::pg_query::Node& RowCompareExpr::_internal_opnos(int index) const { return _impl_.opnos_.Get(index); } inline const ::pg_query::Node& RowCompareExpr::opnos(int index) const { // @@protoc_insertion_point(field_get:pg_query.RowCompareExpr.opnos) return _internal_opnos(index); } inline ::pg_query::Node* RowCompareExpr::_internal_add_opnos() { return _impl_.opnos_.Add(); } inline ::pg_query::Node* RowCompareExpr::add_opnos() { ::pg_query::Node* _add = _internal_add_opnos(); // @@protoc_insertion_point(field_add:pg_query.RowCompareExpr.opnos) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& RowCompareExpr::opnos() const { // @@protoc_insertion_point(field_list:pg_query.RowCompareExpr.opnos) return _impl_.opnos_; } // repeated .pg_query.Node opfamilies = 4 [json_name = "opfamilies"]; inline int RowCompareExpr::_internal_opfamilies_size() const { return _impl_.opfamilies_.size(); } inline int RowCompareExpr::opfamilies_size() const { return _internal_opfamilies_size(); } inline void RowCompareExpr::clear_opfamilies() { _impl_.opfamilies_.Clear(); } inline ::pg_query::Node* RowCompareExpr::mutable_opfamilies(int index) { // @@protoc_insertion_point(field_mutable:pg_query.RowCompareExpr.opfamilies) return _impl_.opfamilies_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* RowCompareExpr::mutable_opfamilies() { // @@protoc_insertion_point(field_mutable_list:pg_query.RowCompareExpr.opfamilies) return &_impl_.opfamilies_; } inline const ::pg_query::Node& RowCompareExpr::_internal_opfamilies(int index) const { return _impl_.opfamilies_.Get(index); } inline const ::pg_query::Node& RowCompareExpr::opfamilies(int index) const { // @@protoc_insertion_point(field_get:pg_query.RowCompareExpr.opfamilies) return _internal_opfamilies(index); } inline ::pg_query::Node* RowCompareExpr::_internal_add_opfamilies() { return _impl_.opfamilies_.Add(); } inline ::pg_query::Node* RowCompareExpr::add_opfamilies() { ::pg_query::Node* _add = _internal_add_opfamilies(); // @@protoc_insertion_point(field_add:pg_query.RowCompareExpr.opfamilies) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& RowCompareExpr::opfamilies() const { // @@protoc_insertion_point(field_list:pg_query.RowCompareExpr.opfamilies) return _impl_.opfamilies_; } // repeated .pg_query.Node inputcollids = 5 [json_name = "inputcollids"]; inline int RowCompareExpr::_internal_inputcollids_size() const { return _impl_.inputcollids_.size(); } inline int RowCompareExpr::inputcollids_size() const { return _internal_inputcollids_size(); } inline void RowCompareExpr::clear_inputcollids() { _impl_.inputcollids_.Clear(); } inline ::pg_query::Node* RowCompareExpr::mutable_inputcollids(int index) { // @@protoc_insertion_point(field_mutable:pg_query.RowCompareExpr.inputcollids) return _impl_.inputcollids_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* RowCompareExpr::mutable_inputcollids() { // @@protoc_insertion_point(field_mutable_list:pg_query.RowCompareExpr.inputcollids) return &_impl_.inputcollids_; } inline const ::pg_query::Node& RowCompareExpr::_internal_inputcollids(int index) const { return _impl_.inputcollids_.Get(index); } inline const ::pg_query::Node& RowCompareExpr::inputcollids(int index) const { // @@protoc_insertion_point(field_get:pg_query.RowCompareExpr.inputcollids) return _internal_inputcollids(index); } inline ::pg_query::Node* RowCompareExpr::_internal_add_inputcollids() { return _impl_.inputcollids_.Add(); } inline ::pg_query::Node* RowCompareExpr::add_inputcollids() { ::pg_query::Node* _add = _internal_add_inputcollids(); // @@protoc_insertion_point(field_add:pg_query.RowCompareExpr.inputcollids) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& RowCompareExpr::inputcollids() const { // @@protoc_insertion_point(field_list:pg_query.RowCompareExpr.inputcollids) return _impl_.inputcollids_; } // repeated .pg_query.Node largs = 6 [json_name = "largs"]; inline int RowCompareExpr::_internal_largs_size() const { return _impl_.largs_.size(); } inline int RowCompareExpr::largs_size() const { return _internal_largs_size(); } inline void RowCompareExpr::clear_largs() { _impl_.largs_.Clear(); } inline ::pg_query::Node* RowCompareExpr::mutable_largs(int index) { // @@protoc_insertion_point(field_mutable:pg_query.RowCompareExpr.largs) return _impl_.largs_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* RowCompareExpr::mutable_largs() { // @@protoc_insertion_point(field_mutable_list:pg_query.RowCompareExpr.largs) return &_impl_.largs_; } inline const ::pg_query::Node& RowCompareExpr::_internal_largs(int index) const { return _impl_.largs_.Get(index); } inline const ::pg_query::Node& RowCompareExpr::largs(int index) const { // @@protoc_insertion_point(field_get:pg_query.RowCompareExpr.largs) return _internal_largs(index); } inline ::pg_query::Node* RowCompareExpr::_internal_add_largs() { return _impl_.largs_.Add(); } inline ::pg_query::Node* RowCompareExpr::add_largs() { ::pg_query::Node* _add = _internal_add_largs(); // @@protoc_insertion_point(field_add:pg_query.RowCompareExpr.largs) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& RowCompareExpr::largs() const { // @@protoc_insertion_point(field_list:pg_query.RowCompareExpr.largs) return _impl_.largs_; } // repeated .pg_query.Node rargs = 7 [json_name = "rargs"]; inline int RowCompareExpr::_internal_rargs_size() const { return _impl_.rargs_.size(); } inline int RowCompareExpr::rargs_size() const { return _internal_rargs_size(); } inline void RowCompareExpr::clear_rargs() { _impl_.rargs_.Clear(); } inline ::pg_query::Node* RowCompareExpr::mutable_rargs(int index) { // @@protoc_insertion_point(field_mutable:pg_query.RowCompareExpr.rargs) return _impl_.rargs_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* RowCompareExpr::mutable_rargs() { // @@protoc_insertion_point(field_mutable_list:pg_query.RowCompareExpr.rargs) return &_impl_.rargs_; } inline const ::pg_query::Node& RowCompareExpr::_internal_rargs(int index) const { return _impl_.rargs_.Get(index); } inline const ::pg_query::Node& RowCompareExpr::rargs(int index) const { // @@protoc_insertion_point(field_get:pg_query.RowCompareExpr.rargs) return _internal_rargs(index); } inline ::pg_query::Node* RowCompareExpr::_internal_add_rargs() { return _impl_.rargs_.Add(); } inline ::pg_query::Node* RowCompareExpr::add_rargs() { ::pg_query::Node* _add = _internal_add_rargs(); // @@protoc_insertion_point(field_add:pg_query.RowCompareExpr.rargs) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& RowCompareExpr::rargs() const { // @@protoc_insertion_point(field_list:pg_query.RowCompareExpr.rargs) return _impl_.rargs_; } // ------------------------------------------------------------------- // CoalesceExpr // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool CoalesceExpr::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool CoalesceExpr::has_xpr() const { return _internal_has_xpr(); } inline void CoalesceExpr::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& CoalesceExpr::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& CoalesceExpr::xpr() const { // @@protoc_insertion_point(field_get:pg_query.CoalesceExpr.xpr) return _internal_xpr(); } inline void CoalesceExpr::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CoalesceExpr.xpr) } inline ::pg_query::Node* CoalesceExpr::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* CoalesceExpr::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.CoalesceExpr.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* CoalesceExpr::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* CoalesceExpr::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.CoalesceExpr.xpr) } // uint32 coalescetype = 2 [json_name = "coalescetype"]; inline void CoalesceExpr::clear_coalescetype() { _impl_.coalescetype_ = 0u; } inline uint32_t CoalesceExpr::_internal_coalescetype() const { return _impl_.coalescetype_; } inline uint32_t CoalesceExpr::coalescetype() const { // @@protoc_insertion_point(field_get:pg_query.CoalesceExpr.coalescetype) return _internal_coalescetype(); } inline void CoalesceExpr::_internal_set_coalescetype(uint32_t value) { _impl_.coalescetype_ = value; } inline void CoalesceExpr::set_coalescetype(uint32_t value) { _internal_set_coalescetype(value); // @@protoc_insertion_point(field_set:pg_query.CoalesceExpr.coalescetype) } // uint32 coalescecollid = 3 [json_name = "coalescecollid"]; inline void CoalesceExpr::clear_coalescecollid() { _impl_.coalescecollid_ = 0u; } inline uint32_t CoalesceExpr::_internal_coalescecollid() const { return _impl_.coalescecollid_; } inline uint32_t CoalesceExpr::coalescecollid() const { // @@protoc_insertion_point(field_get:pg_query.CoalesceExpr.coalescecollid) return _internal_coalescecollid(); } inline void CoalesceExpr::_internal_set_coalescecollid(uint32_t value) { _impl_.coalescecollid_ = value; } inline void CoalesceExpr::set_coalescecollid(uint32_t value) { _internal_set_coalescecollid(value); // @@protoc_insertion_point(field_set:pg_query.CoalesceExpr.coalescecollid) } // repeated .pg_query.Node args = 4 [json_name = "args"]; inline int CoalesceExpr::_internal_args_size() const { return _impl_.args_.size(); } inline int CoalesceExpr::args_size() const { return _internal_args_size(); } inline void CoalesceExpr::clear_args() { _impl_.args_.Clear(); } inline ::pg_query::Node* CoalesceExpr::mutable_args(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CoalesceExpr.args) return _impl_.args_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CoalesceExpr::mutable_args() { // @@protoc_insertion_point(field_mutable_list:pg_query.CoalesceExpr.args) return &_impl_.args_; } inline const ::pg_query::Node& CoalesceExpr::_internal_args(int index) const { return _impl_.args_.Get(index); } inline const ::pg_query::Node& CoalesceExpr::args(int index) const { // @@protoc_insertion_point(field_get:pg_query.CoalesceExpr.args) return _internal_args(index); } inline ::pg_query::Node* CoalesceExpr::_internal_add_args() { return _impl_.args_.Add(); } inline ::pg_query::Node* CoalesceExpr::add_args() { ::pg_query::Node* _add = _internal_add_args(); // @@protoc_insertion_point(field_add:pg_query.CoalesceExpr.args) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CoalesceExpr::args() const { // @@protoc_insertion_point(field_list:pg_query.CoalesceExpr.args) return _impl_.args_; } // int32 location = 5 [json_name = "location"]; inline void CoalesceExpr::clear_location() { _impl_.location_ = 0; } inline int32_t CoalesceExpr::_internal_location() const { return _impl_.location_; } inline int32_t CoalesceExpr::location() const { // @@protoc_insertion_point(field_get:pg_query.CoalesceExpr.location) return _internal_location(); } inline void CoalesceExpr::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void CoalesceExpr::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.CoalesceExpr.location) } // ------------------------------------------------------------------- // MinMaxExpr // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool MinMaxExpr::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool MinMaxExpr::has_xpr() const { return _internal_has_xpr(); } inline void MinMaxExpr::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& MinMaxExpr::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& MinMaxExpr::xpr() const { // @@protoc_insertion_point(field_get:pg_query.MinMaxExpr.xpr) return _internal_xpr(); } inline void MinMaxExpr::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.MinMaxExpr.xpr) } inline ::pg_query::Node* MinMaxExpr::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* MinMaxExpr::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.MinMaxExpr.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* MinMaxExpr::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* MinMaxExpr::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.MinMaxExpr.xpr) } // uint32 minmaxtype = 2 [json_name = "minmaxtype"]; inline void MinMaxExpr::clear_minmaxtype() { _impl_.minmaxtype_ = 0u; } inline uint32_t MinMaxExpr::_internal_minmaxtype() const { return _impl_.minmaxtype_; } inline uint32_t MinMaxExpr::minmaxtype() const { // @@protoc_insertion_point(field_get:pg_query.MinMaxExpr.minmaxtype) return _internal_minmaxtype(); } inline void MinMaxExpr::_internal_set_minmaxtype(uint32_t value) { _impl_.minmaxtype_ = value; } inline void MinMaxExpr::set_minmaxtype(uint32_t value) { _internal_set_minmaxtype(value); // @@protoc_insertion_point(field_set:pg_query.MinMaxExpr.minmaxtype) } // uint32 minmaxcollid = 3 [json_name = "minmaxcollid"]; inline void MinMaxExpr::clear_minmaxcollid() { _impl_.minmaxcollid_ = 0u; } inline uint32_t MinMaxExpr::_internal_minmaxcollid() const { return _impl_.minmaxcollid_; } inline uint32_t MinMaxExpr::minmaxcollid() const { // @@protoc_insertion_point(field_get:pg_query.MinMaxExpr.minmaxcollid) return _internal_minmaxcollid(); } inline void MinMaxExpr::_internal_set_minmaxcollid(uint32_t value) { _impl_.minmaxcollid_ = value; } inline void MinMaxExpr::set_minmaxcollid(uint32_t value) { _internal_set_minmaxcollid(value); // @@protoc_insertion_point(field_set:pg_query.MinMaxExpr.minmaxcollid) } // uint32 inputcollid = 4 [json_name = "inputcollid"]; inline void MinMaxExpr::clear_inputcollid() { _impl_.inputcollid_ = 0u; } inline uint32_t MinMaxExpr::_internal_inputcollid() const { return _impl_.inputcollid_; } inline uint32_t MinMaxExpr::inputcollid() const { // @@protoc_insertion_point(field_get:pg_query.MinMaxExpr.inputcollid) return _internal_inputcollid(); } inline void MinMaxExpr::_internal_set_inputcollid(uint32_t value) { _impl_.inputcollid_ = value; } inline void MinMaxExpr::set_inputcollid(uint32_t value) { _internal_set_inputcollid(value); // @@protoc_insertion_point(field_set:pg_query.MinMaxExpr.inputcollid) } // .pg_query.MinMaxOp op = 5 [json_name = "op"]; inline void MinMaxExpr::clear_op() { _impl_.op_ = 0; } inline ::pg_query::MinMaxOp MinMaxExpr::_internal_op() const { return static_cast< ::pg_query::MinMaxOp >(_impl_.op_); } inline ::pg_query::MinMaxOp MinMaxExpr::op() const { // @@protoc_insertion_point(field_get:pg_query.MinMaxExpr.op) return _internal_op(); } inline void MinMaxExpr::_internal_set_op(::pg_query::MinMaxOp value) { _impl_.op_ = value; } inline void MinMaxExpr::set_op(::pg_query::MinMaxOp value) { _internal_set_op(value); // @@protoc_insertion_point(field_set:pg_query.MinMaxExpr.op) } // repeated .pg_query.Node args = 6 [json_name = "args"]; inline int MinMaxExpr::_internal_args_size() const { return _impl_.args_.size(); } inline int MinMaxExpr::args_size() const { return _internal_args_size(); } inline void MinMaxExpr::clear_args() { _impl_.args_.Clear(); } inline ::pg_query::Node* MinMaxExpr::mutable_args(int index) { // @@protoc_insertion_point(field_mutable:pg_query.MinMaxExpr.args) return _impl_.args_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* MinMaxExpr::mutable_args() { // @@protoc_insertion_point(field_mutable_list:pg_query.MinMaxExpr.args) return &_impl_.args_; } inline const ::pg_query::Node& MinMaxExpr::_internal_args(int index) const { return _impl_.args_.Get(index); } inline const ::pg_query::Node& MinMaxExpr::args(int index) const { // @@protoc_insertion_point(field_get:pg_query.MinMaxExpr.args) return _internal_args(index); } inline ::pg_query::Node* MinMaxExpr::_internal_add_args() { return _impl_.args_.Add(); } inline ::pg_query::Node* MinMaxExpr::add_args() { ::pg_query::Node* _add = _internal_add_args(); // @@protoc_insertion_point(field_add:pg_query.MinMaxExpr.args) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& MinMaxExpr::args() const { // @@protoc_insertion_point(field_list:pg_query.MinMaxExpr.args) return _impl_.args_; } // int32 location = 7 [json_name = "location"]; inline void MinMaxExpr::clear_location() { _impl_.location_ = 0; } inline int32_t MinMaxExpr::_internal_location() const { return _impl_.location_; } inline int32_t MinMaxExpr::location() const { // @@protoc_insertion_point(field_get:pg_query.MinMaxExpr.location) return _internal_location(); } inline void MinMaxExpr::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void MinMaxExpr::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.MinMaxExpr.location) } // ------------------------------------------------------------------- // SQLValueFunction // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool SQLValueFunction::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool SQLValueFunction::has_xpr() const { return _internal_has_xpr(); } inline void SQLValueFunction::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& SQLValueFunction::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& SQLValueFunction::xpr() const { // @@protoc_insertion_point(field_get:pg_query.SQLValueFunction.xpr) return _internal_xpr(); } inline void SQLValueFunction::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SQLValueFunction.xpr) } inline ::pg_query::Node* SQLValueFunction::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* SQLValueFunction::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.SQLValueFunction.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* SQLValueFunction::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* SQLValueFunction::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.SQLValueFunction.xpr) } // .pg_query.SQLValueFunctionOp op = 2 [json_name = "op"]; inline void SQLValueFunction::clear_op() { _impl_.op_ = 0; } inline ::pg_query::SQLValueFunctionOp SQLValueFunction::_internal_op() const { return static_cast< ::pg_query::SQLValueFunctionOp >(_impl_.op_); } inline ::pg_query::SQLValueFunctionOp SQLValueFunction::op() const { // @@protoc_insertion_point(field_get:pg_query.SQLValueFunction.op) return _internal_op(); } inline void SQLValueFunction::_internal_set_op(::pg_query::SQLValueFunctionOp value) { _impl_.op_ = value; } inline void SQLValueFunction::set_op(::pg_query::SQLValueFunctionOp value) { _internal_set_op(value); // @@protoc_insertion_point(field_set:pg_query.SQLValueFunction.op) } // uint32 type = 3 [json_name = "type"]; inline void SQLValueFunction::clear_type() { _impl_.type_ = 0u; } inline uint32_t SQLValueFunction::_internal_type() const { return _impl_.type_; } inline uint32_t SQLValueFunction::type() const { // @@protoc_insertion_point(field_get:pg_query.SQLValueFunction.type) return _internal_type(); } inline void SQLValueFunction::_internal_set_type(uint32_t value) { _impl_.type_ = value; } inline void SQLValueFunction::set_type(uint32_t value) { _internal_set_type(value); // @@protoc_insertion_point(field_set:pg_query.SQLValueFunction.type) } // int32 typmod = 4 [json_name = "typmod"]; inline void SQLValueFunction::clear_typmod() { _impl_.typmod_ = 0; } inline int32_t SQLValueFunction::_internal_typmod() const { return _impl_.typmod_; } inline int32_t SQLValueFunction::typmod() const { // @@protoc_insertion_point(field_get:pg_query.SQLValueFunction.typmod) return _internal_typmod(); } inline void SQLValueFunction::_internal_set_typmod(int32_t value) { _impl_.typmod_ = value; } inline void SQLValueFunction::set_typmod(int32_t value) { _internal_set_typmod(value); // @@protoc_insertion_point(field_set:pg_query.SQLValueFunction.typmod) } // int32 location = 5 [json_name = "location"]; inline void SQLValueFunction::clear_location() { _impl_.location_ = 0; } inline int32_t SQLValueFunction::_internal_location() const { return _impl_.location_; } inline int32_t SQLValueFunction::location() const { // @@protoc_insertion_point(field_get:pg_query.SQLValueFunction.location) return _internal_location(); } inline void SQLValueFunction::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void SQLValueFunction::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.SQLValueFunction.location) } // ------------------------------------------------------------------- // XmlExpr // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool XmlExpr::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool XmlExpr::has_xpr() const { return _internal_has_xpr(); } inline void XmlExpr::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& XmlExpr::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& XmlExpr::xpr() const { // @@protoc_insertion_point(field_get:pg_query.XmlExpr.xpr) return _internal_xpr(); } inline void XmlExpr::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.XmlExpr.xpr) } inline ::pg_query::Node* XmlExpr::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* XmlExpr::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.XmlExpr.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* XmlExpr::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* XmlExpr::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.XmlExpr.xpr) } // .pg_query.XmlExprOp op = 2 [json_name = "op"]; inline void XmlExpr::clear_op() { _impl_.op_ = 0; } inline ::pg_query::XmlExprOp XmlExpr::_internal_op() const { return static_cast< ::pg_query::XmlExprOp >(_impl_.op_); } inline ::pg_query::XmlExprOp XmlExpr::op() const { // @@protoc_insertion_point(field_get:pg_query.XmlExpr.op) return _internal_op(); } inline void XmlExpr::_internal_set_op(::pg_query::XmlExprOp value) { _impl_.op_ = value; } inline void XmlExpr::set_op(::pg_query::XmlExprOp value) { _internal_set_op(value); // @@protoc_insertion_point(field_set:pg_query.XmlExpr.op) } // string name = 3 [json_name = "name"]; inline void XmlExpr::clear_name() { _impl_.name_.ClearToEmpty(); } inline const std::string& XmlExpr::name() const { // @@protoc_insertion_point(field_get:pg_query.XmlExpr.name) return _internal_name(); } template inline PROTOBUF_ALWAYS_INLINE void XmlExpr::set_name(ArgT0&& arg0, ArgT... args) { _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.XmlExpr.name) } inline std::string* XmlExpr::mutable_name() { 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 { return _impl_.name_.Get(); } inline void XmlExpr::_internal_set_name(const std::string& value) { _impl_.name_.Set(value, GetArenaForAllocation()); } inline std::string* XmlExpr::_internal_mutable_name() { return _impl_.name_.Mutable(GetArenaForAllocation()); } inline std::string* XmlExpr::release_name() { // @@protoc_insertion_point(field_release:pg_query.XmlExpr.name) return _impl_.name_.Release(); } inline void XmlExpr::set_allocated_name(std::string* name) { if (name != nullptr) { } else { } _impl_.name_.SetAllocated(name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.name_.IsDefault()) { _impl_.name_.Set("", GetArenaForAllocation()); } #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 _impl_.named_args_.size(); } inline int XmlExpr::named_args_size() const { return _internal_named_args_size(); } inline void XmlExpr::clear_named_args() { _impl_.named_args_.Clear(); } inline ::pg_query::Node* XmlExpr::mutable_named_args(int index) { // @@protoc_insertion_point(field_mutable:pg_query.XmlExpr.named_args) return _impl_.named_args_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* XmlExpr::mutable_named_args() { // @@protoc_insertion_point(field_mutable_list:pg_query.XmlExpr.named_args) return &_impl_.named_args_; } inline const ::pg_query::Node& XmlExpr::_internal_named_args(int index) const { return _impl_.named_args_.Get(index); } inline const ::pg_query::Node& XmlExpr::named_args(int index) const { // @@protoc_insertion_point(field_get:pg_query.XmlExpr.named_args) return _internal_named_args(index); } inline ::pg_query::Node* XmlExpr::_internal_add_named_args() { return _impl_.named_args_.Add(); } inline ::pg_query::Node* XmlExpr::add_named_args() { ::pg_query::Node* _add = _internal_add_named_args(); // @@protoc_insertion_point(field_add:pg_query.XmlExpr.named_args) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& XmlExpr::named_args() const { // @@protoc_insertion_point(field_list:pg_query.XmlExpr.named_args) return _impl_.named_args_; } // repeated .pg_query.Node arg_names = 5 [json_name = "arg_names"]; inline int XmlExpr::_internal_arg_names_size() const { return _impl_.arg_names_.size(); } inline int XmlExpr::arg_names_size() const { return _internal_arg_names_size(); } inline void XmlExpr::clear_arg_names() { _impl_.arg_names_.Clear(); } inline ::pg_query::Node* XmlExpr::mutable_arg_names(int index) { // @@protoc_insertion_point(field_mutable:pg_query.XmlExpr.arg_names) return _impl_.arg_names_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* XmlExpr::mutable_arg_names() { // @@protoc_insertion_point(field_mutable_list:pg_query.XmlExpr.arg_names) return &_impl_.arg_names_; } inline const ::pg_query::Node& XmlExpr::_internal_arg_names(int index) const { return _impl_.arg_names_.Get(index); } inline const ::pg_query::Node& XmlExpr::arg_names(int index) const { // @@protoc_insertion_point(field_get:pg_query.XmlExpr.arg_names) return _internal_arg_names(index); } inline ::pg_query::Node* XmlExpr::_internal_add_arg_names() { return _impl_.arg_names_.Add(); } inline ::pg_query::Node* XmlExpr::add_arg_names() { ::pg_query::Node* _add = _internal_add_arg_names(); // @@protoc_insertion_point(field_add:pg_query.XmlExpr.arg_names) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& XmlExpr::arg_names() const { // @@protoc_insertion_point(field_list:pg_query.XmlExpr.arg_names) return _impl_.arg_names_; } // repeated .pg_query.Node args = 6 [json_name = "args"]; inline int XmlExpr::_internal_args_size() const { return _impl_.args_.size(); } inline int XmlExpr::args_size() const { return _internal_args_size(); } inline void XmlExpr::clear_args() { _impl_.args_.Clear(); } inline ::pg_query::Node* XmlExpr::mutable_args(int index) { // @@protoc_insertion_point(field_mutable:pg_query.XmlExpr.args) return _impl_.args_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* XmlExpr::mutable_args() { // @@protoc_insertion_point(field_mutable_list:pg_query.XmlExpr.args) return &_impl_.args_; } inline const ::pg_query::Node& XmlExpr::_internal_args(int index) const { return _impl_.args_.Get(index); } inline const ::pg_query::Node& XmlExpr::args(int index) const { // @@protoc_insertion_point(field_get:pg_query.XmlExpr.args) return _internal_args(index); } inline ::pg_query::Node* XmlExpr::_internal_add_args() { return _impl_.args_.Add(); } inline ::pg_query::Node* XmlExpr::add_args() { ::pg_query::Node* _add = _internal_add_args(); // @@protoc_insertion_point(field_add:pg_query.XmlExpr.args) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& XmlExpr::args() const { // @@protoc_insertion_point(field_list:pg_query.XmlExpr.args) return _impl_.args_; } // .pg_query.XmlOptionType xmloption = 7 [json_name = "xmloption"]; inline void XmlExpr::clear_xmloption() { _impl_.xmloption_ = 0; } inline ::pg_query::XmlOptionType XmlExpr::_internal_xmloption() const { return static_cast< ::pg_query::XmlOptionType >(_impl_.xmloption_); } inline ::pg_query::XmlOptionType XmlExpr::xmloption() const { // @@protoc_insertion_point(field_get:pg_query.XmlExpr.xmloption) return _internal_xmloption(); } inline void XmlExpr::_internal_set_xmloption(::pg_query::XmlOptionType value) { _impl_.xmloption_ = value; } inline void XmlExpr::set_xmloption(::pg_query::XmlOptionType value) { _internal_set_xmloption(value); // @@protoc_insertion_point(field_set:pg_query.XmlExpr.xmloption) } // uint32 type = 8 [json_name = "type"]; inline void XmlExpr::clear_type() { _impl_.type_ = 0u; } inline uint32_t XmlExpr::_internal_type() const { return _impl_.type_; } inline uint32_t XmlExpr::type() const { // @@protoc_insertion_point(field_get:pg_query.XmlExpr.type) return _internal_type(); } inline void XmlExpr::_internal_set_type(uint32_t value) { _impl_.type_ = value; } inline void XmlExpr::set_type(uint32_t value) { _internal_set_type(value); // @@protoc_insertion_point(field_set:pg_query.XmlExpr.type) } // int32 typmod = 9 [json_name = "typmod"]; inline void XmlExpr::clear_typmod() { _impl_.typmod_ = 0; } inline int32_t XmlExpr::_internal_typmod() const { return _impl_.typmod_; } inline int32_t XmlExpr::typmod() const { // @@protoc_insertion_point(field_get:pg_query.XmlExpr.typmod) return _internal_typmod(); } inline void XmlExpr::_internal_set_typmod(int32_t value) { _impl_.typmod_ = value; } inline void XmlExpr::set_typmod(int32_t value) { _internal_set_typmod(value); // @@protoc_insertion_point(field_set:pg_query.XmlExpr.typmod) } // int32 location = 10 [json_name = "location"]; inline void XmlExpr::clear_location() { _impl_.location_ = 0; } inline int32_t XmlExpr::_internal_location() const { return _impl_.location_; } inline int32_t XmlExpr::location() const { // @@protoc_insertion_point(field_get:pg_query.XmlExpr.location) return _internal_location(); } inline void XmlExpr::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void XmlExpr::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.XmlExpr.location) } // ------------------------------------------------------------------- // NullTest // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool NullTest::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool NullTest::has_xpr() const { return _internal_has_xpr(); } inline void NullTest::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& NullTest::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& NullTest::xpr() const { // @@protoc_insertion_point(field_get:pg_query.NullTest.xpr) return _internal_xpr(); } inline void NullTest::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.NullTest.xpr) } inline ::pg_query::Node* NullTest::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* NullTest::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.NullTest.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* NullTest::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* NullTest::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.NullTest.xpr) } // .pg_query.Node arg = 2 [json_name = "arg"]; inline bool NullTest::_internal_has_arg() const { return this != internal_default_instance() && _impl_.arg_ != nullptr; } inline bool NullTest::has_arg() const { return _internal_has_arg(); } inline void NullTest::clear_arg() { if (GetArenaForAllocation() == nullptr && _impl_.arg_ != nullptr) { delete _impl_.arg_; } _impl_.arg_ = nullptr; } inline const ::pg_query::Node& NullTest::_internal_arg() const { const ::pg_query::Node* p = _impl_.arg_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& NullTest::arg() const { // @@protoc_insertion_point(field_get:pg_query.NullTest.arg) return _internal_arg(); } inline void NullTest::unsafe_arena_set_allocated_arg( ::pg_query::Node* arg) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.arg_); } _impl_.arg_ = arg; if (arg) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.NullTest.arg) } inline ::pg_query::Node* NullTest::release_arg() { ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* NullTest::unsafe_arena_release_arg() { // @@protoc_insertion_point(field_release:pg_query.NullTest.arg) ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; return temp; } inline ::pg_query::Node* NullTest::_internal_mutable_arg() { if (_impl_.arg_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.arg_ = p; } return _impl_.arg_; } inline ::pg_query::Node* NullTest::mutable_arg() { ::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* arg) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.arg_; } if (arg) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(arg); if (message_arena != submessage_arena) { arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, arg, submessage_arena); } } else { } _impl_.arg_ = arg; // @@protoc_insertion_point(field_set_allocated:pg_query.NullTest.arg) } // .pg_query.NullTestType nulltesttype = 3 [json_name = "nulltesttype"]; inline void NullTest::clear_nulltesttype() { _impl_.nulltesttype_ = 0; } inline ::pg_query::NullTestType NullTest::_internal_nulltesttype() const { return static_cast< ::pg_query::NullTestType >(_impl_.nulltesttype_); } inline ::pg_query::NullTestType NullTest::nulltesttype() const { // @@protoc_insertion_point(field_get:pg_query.NullTest.nulltesttype) return _internal_nulltesttype(); } inline void NullTest::_internal_set_nulltesttype(::pg_query::NullTestType value) { _impl_.nulltesttype_ = value; } inline void NullTest::set_nulltesttype(::pg_query::NullTestType value) { _internal_set_nulltesttype(value); // @@protoc_insertion_point(field_set:pg_query.NullTest.nulltesttype) } // bool argisrow = 4 [json_name = "argisrow"]; inline void NullTest::clear_argisrow() { _impl_.argisrow_ = false; } inline bool NullTest::_internal_argisrow() const { return _impl_.argisrow_; } inline bool NullTest::argisrow() const { // @@protoc_insertion_point(field_get:pg_query.NullTest.argisrow) return _internal_argisrow(); } inline void NullTest::_internal_set_argisrow(bool value) { _impl_.argisrow_ = value; } inline void NullTest::set_argisrow(bool value) { _internal_set_argisrow(value); // @@protoc_insertion_point(field_set:pg_query.NullTest.argisrow) } // int32 location = 5 [json_name = "location"]; inline void NullTest::clear_location() { _impl_.location_ = 0; } inline int32_t NullTest::_internal_location() const { return _impl_.location_; } inline int32_t NullTest::location() const { // @@protoc_insertion_point(field_get:pg_query.NullTest.location) return _internal_location(); } inline void NullTest::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void NullTest::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.NullTest.location) } // ------------------------------------------------------------------- // BooleanTest // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool BooleanTest::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool BooleanTest::has_xpr() const { return _internal_has_xpr(); } inline void BooleanTest::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& BooleanTest::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& BooleanTest::xpr() const { // @@protoc_insertion_point(field_get:pg_query.BooleanTest.xpr) return _internal_xpr(); } inline void BooleanTest::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.BooleanTest.xpr) } inline ::pg_query::Node* BooleanTest::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* BooleanTest::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.BooleanTest.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* BooleanTest::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* BooleanTest::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.BooleanTest.xpr) } // .pg_query.Node arg = 2 [json_name = "arg"]; inline bool BooleanTest::_internal_has_arg() const { return this != internal_default_instance() && _impl_.arg_ != nullptr; } inline bool BooleanTest::has_arg() const { return _internal_has_arg(); } inline void BooleanTest::clear_arg() { if (GetArenaForAllocation() == nullptr && _impl_.arg_ != nullptr) { delete _impl_.arg_; } _impl_.arg_ = nullptr; } inline const ::pg_query::Node& BooleanTest::_internal_arg() const { const ::pg_query::Node* p = _impl_.arg_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& BooleanTest::arg() const { // @@protoc_insertion_point(field_get:pg_query.BooleanTest.arg) return _internal_arg(); } inline void BooleanTest::unsafe_arena_set_allocated_arg( ::pg_query::Node* arg) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.arg_); } _impl_.arg_ = arg; if (arg) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.BooleanTest.arg) } inline ::pg_query::Node* BooleanTest::release_arg() { ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* BooleanTest::unsafe_arena_release_arg() { // @@protoc_insertion_point(field_release:pg_query.BooleanTest.arg) ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; return temp; } inline ::pg_query::Node* BooleanTest::_internal_mutable_arg() { if (_impl_.arg_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.arg_ = p; } return _impl_.arg_; } inline ::pg_query::Node* BooleanTest::mutable_arg() { ::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* arg) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.arg_; } if (arg) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(arg); if (message_arena != submessage_arena) { arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, arg, submessage_arena); } } else { } _impl_.arg_ = arg; // @@protoc_insertion_point(field_set_allocated:pg_query.BooleanTest.arg) } // .pg_query.BoolTestType booltesttype = 3 [json_name = "booltesttype"]; inline void BooleanTest::clear_booltesttype() { _impl_.booltesttype_ = 0; } inline ::pg_query::BoolTestType BooleanTest::_internal_booltesttype() const { return static_cast< ::pg_query::BoolTestType >(_impl_.booltesttype_); } inline ::pg_query::BoolTestType BooleanTest::booltesttype() const { // @@protoc_insertion_point(field_get:pg_query.BooleanTest.booltesttype) return _internal_booltesttype(); } inline void BooleanTest::_internal_set_booltesttype(::pg_query::BoolTestType value) { _impl_.booltesttype_ = value; } inline void BooleanTest::set_booltesttype(::pg_query::BoolTestType value) { _internal_set_booltesttype(value); // @@protoc_insertion_point(field_set:pg_query.BooleanTest.booltesttype) } // int32 location = 4 [json_name = "location"]; inline void BooleanTest::clear_location() { _impl_.location_ = 0; } inline int32_t BooleanTest::_internal_location() const { return _impl_.location_; } inline int32_t BooleanTest::location() const { // @@protoc_insertion_point(field_get:pg_query.BooleanTest.location) return _internal_location(); } inline void BooleanTest::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void BooleanTest::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.BooleanTest.location) } // ------------------------------------------------------------------- // CoerceToDomain // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool CoerceToDomain::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool CoerceToDomain::has_xpr() const { return _internal_has_xpr(); } inline void CoerceToDomain::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& CoerceToDomain::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& CoerceToDomain::xpr() const { // @@protoc_insertion_point(field_get:pg_query.CoerceToDomain.xpr) return _internal_xpr(); } inline void CoerceToDomain::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CoerceToDomain.xpr) } inline ::pg_query::Node* CoerceToDomain::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* CoerceToDomain::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.CoerceToDomain.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* CoerceToDomain::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* CoerceToDomain::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.CoerceToDomain.xpr) } // .pg_query.Node arg = 2 [json_name = "arg"]; inline bool CoerceToDomain::_internal_has_arg() const { return this != internal_default_instance() && _impl_.arg_ != nullptr; } inline bool CoerceToDomain::has_arg() const { return _internal_has_arg(); } inline void CoerceToDomain::clear_arg() { if (GetArenaForAllocation() == nullptr && _impl_.arg_ != nullptr) { delete _impl_.arg_; } _impl_.arg_ = nullptr; } inline const ::pg_query::Node& CoerceToDomain::_internal_arg() const { const ::pg_query::Node* p = _impl_.arg_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& CoerceToDomain::arg() const { // @@protoc_insertion_point(field_get:pg_query.CoerceToDomain.arg) return _internal_arg(); } inline void CoerceToDomain::unsafe_arena_set_allocated_arg( ::pg_query::Node* arg) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.arg_); } _impl_.arg_ = arg; if (arg) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CoerceToDomain.arg) } inline ::pg_query::Node* CoerceToDomain::release_arg() { ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* CoerceToDomain::unsafe_arena_release_arg() { // @@protoc_insertion_point(field_release:pg_query.CoerceToDomain.arg) ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; return temp; } inline ::pg_query::Node* CoerceToDomain::_internal_mutable_arg() { if (_impl_.arg_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.arg_ = p; } return _impl_.arg_; } inline ::pg_query::Node* CoerceToDomain::mutable_arg() { ::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* arg) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.arg_; } if (arg) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(arg); if (message_arena != submessage_arena) { arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, arg, submessage_arena); } } else { } _impl_.arg_ = arg; // @@protoc_insertion_point(field_set_allocated:pg_query.CoerceToDomain.arg) } // uint32 resulttype = 3 [json_name = "resulttype"]; inline void CoerceToDomain::clear_resulttype() { _impl_.resulttype_ = 0u; } inline uint32_t CoerceToDomain::_internal_resulttype() const { return _impl_.resulttype_; } inline uint32_t CoerceToDomain::resulttype() const { // @@protoc_insertion_point(field_get:pg_query.CoerceToDomain.resulttype) return _internal_resulttype(); } inline void CoerceToDomain::_internal_set_resulttype(uint32_t value) { _impl_.resulttype_ = value; } inline void CoerceToDomain::set_resulttype(uint32_t value) { _internal_set_resulttype(value); // @@protoc_insertion_point(field_set:pg_query.CoerceToDomain.resulttype) } // int32 resulttypmod = 4 [json_name = "resulttypmod"]; inline void CoerceToDomain::clear_resulttypmod() { _impl_.resulttypmod_ = 0; } inline int32_t CoerceToDomain::_internal_resulttypmod() const { return _impl_.resulttypmod_; } inline int32_t CoerceToDomain::resulttypmod() const { // @@protoc_insertion_point(field_get:pg_query.CoerceToDomain.resulttypmod) return _internal_resulttypmod(); } inline void CoerceToDomain::_internal_set_resulttypmod(int32_t value) { _impl_.resulttypmod_ = value; } inline void CoerceToDomain::set_resulttypmod(int32_t value) { _internal_set_resulttypmod(value); // @@protoc_insertion_point(field_set:pg_query.CoerceToDomain.resulttypmod) } // uint32 resultcollid = 5 [json_name = "resultcollid"]; inline void CoerceToDomain::clear_resultcollid() { _impl_.resultcollid_ = 0u; } inline uint32_t CoerceToDomain::_internal_resultcollid() const { return _impl_.resultcollid_; } inline uint32_t CoerceToDomain::resultcollid() const { // @@protoc_insertion_point(field_get:pg_query.CoerceToDomain.resultcollid) return _internal_resultcollid(); } inline void CoerceToDomain::_internal_set_resultcollid(uint32_t value) { _impl_.resultcollid_ = value; } inline void CoerceToDomain::set_resultcollid(uint32_t value) { _internal_set_resultcollid(value); // @@protoc_insertion_point(field_set:pg_query.CoerceToDomain.resultcollid) } // .pg_query.CoercionForm coercionformat = 6 [json_name = "coercionformat"]; inline void CoerceToDomain::clear_coercionformat() { _impl_.coercionformat_ = 0; } inline ::pg_query::CoercionForm CoerceToDomain::_internal_coercionformat() const { return static_cast< ::pg_query::CoercionForm >(_impl_.coercionformat_); } inline ::pg_query::CoercionForm CoerceToDomain::coercionformat() const { // @@protoc_insertion_point(field_get:pg_query.CoerceToDomain.coercionformat) return _internal_coercionformat(); } inline void CoerceToDomain::_internal_set_coercionformat(::pg_query::CoercionForm value) { _impl_.coercionformat_ = value; } inline void CoerceToDomain::set_coercionformat(::pg_query::CoercionForm value) { _internal_set_coercionformat(value); // @@protoc_insertion_point(field_set:pg_query.CoerceToDomain.coercionformat) } // int32 location = 7 [json_name = "location"]; inline void CoerceToDomain::clear_location() { _impl_.location_ = 0; } inline int32_t CoerceToDomain::_internal_location() const { return _impl_.location_; } inline int32_t CoerceToDomain::location() const { // @@protoc_insertion_point(field_get:pg_query.CoerceToDomain.location) return _internal_location(); } inline void CoerceToDomain::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void CoerceToDomain::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.CoerceToDomain.location) } // ------------------------------------------------------------------- // CoerceToDomainValue // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool CoerceToDomainValue::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool CoerceToDomainValue::has_xpr() const { return _internal_has_xpr(); } inline void CoerceToDomainValue::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& CoerceToDomainValue::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& CoerceToDomainValue::xpr() const { // @@protoc_insertion_point(field_get:pg_query.CoerceToDomainValue.xpr) return _internal_xpr(); } inline void CoerceToDomainValue::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CoerceToDomainValue.xpr) } inline ::pg_query::Node* CoerceToDomainValue::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* CoerceToDomainValue::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.CoerceToDomainValue.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* CoerceToDomainValue::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* CoerceToDomainValue::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.CoerceToDomainValue.xpr) } // uint32 type_id = 2 [json_name = "typeId"]; inline void CoerceToDomainValue::clear_type_id() { _impl_.type_id_ = 0u; } inline uint32_t CoerceToDomainValue::_internal_type_id() const { return _impl_.type_id_; } inline uint32_t CoerceToDomainValue::type_id() const { // @@protoc_insertion_point(field_get:pg_query.CoerceToDomainValue.type_id) return _internal_type_id(); } inline void CoerceToDomainValue::_internal_set_type_id(uint32_t value) { _impl_.type_id_ = value; } inline void CoerceToDomainValue::set_type_id(uint32_t value) { _internal_set_type_id(value); // @@protoc_insertion_point(field_set:pg_query.CoerceToDomainValue.type_id) } // int32 type_mod = 3 [json_name = "typeMod"]; inline void CoerceToDomainValue::clear_type_mod() { _impl_.type_mod_ = 0; } inline int32_t CoerceToDomainValue::_internal_type_mod() const { return _impl_.type_mod_; } inline int32_t CoerceToDomainValue::type_mod() const { // @@protoc_insertion_point(field_get:pg_query.CoerceToDomainValue.type_mod) return _internal_type_mod(); } inline void CoerceToDomainValue::_internal_set_type_mod(int32_t value) { _impl_.type_mod_ = value; } inline void CoerceToDomainValue::set_type_mod(int32_t value) { _internal_set_type_mod(value); // @@protoc_insertion_point(field_set:pg_query.CoerceToDomainValue.type_mod) } // uint32 collation = 4 [json_name = "collation"]; inline void CoerceToDomainValue::clear_collation() { _impl_.collation_ = 0u; } inline uint32_t CoerceToDomainValue::_internal_collation() const { return _impl_.collation_; } inline uint32_t CoerceToDomainValue::collation() const { // @@protoc_insertion_point(field_get:pg_query.CoerceToDomainValue.collation) return _internal_collation(); } inline void CoerceToDomainValue::_internal_set_collation(uint32_t value) { _impl_.collation_ = value; } inline void CoerceToDomainValue::set_collation(uint32_t value) { _internal_set_collation(value); // @@protoc_insertion_point(field_set:pg_query.CoerceToDomainValue.collation) } // int32 location = 5 [json_name = "location"]; inline void CoerceToDomainValue::clear_location() { _impl_.location_ = 0; } inline int32_t CoerceToDomainValue::_internal_location() const { return _impl_.location_; } inline int32_t CoerceToDomainValue::location() const { // @@protoc_insertion_point(field_get:pg_query.CoerceToDomainValue.location) return _internal_location(); } inline void CoerceToDomainValue::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void CoerceToDomainValue::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.CoerceToDomainValue.location) } // ------------------------------------------------------------------- // SetToDefault // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool SetToDefault::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool SetToDefault::has_xpr() const { return _internal_has_xpr(); } inline void SetToDefault::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& SetToDefault::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& SetToDefault::xpr() const { // @@protoc_insertion_point(field_get:pg_query.SetToDefault.xpr) return _internal_xpr(); } inline void SetToDefault::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SetToDefault.xpr) } inline ::pg_query::Node* SetToDefault::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* SetToDefault::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.SetToDefault.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* SetToDefault::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* SetToDefault::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.SetToDefault.xpr) } // uint32 type_id = 2 [json_name = "typeId"]; inline void SetToDefault::clear_type_id() { _impl_.type_id_ = 0u; } inline uint32_t SetToDefault::_internal_type_id() const { return _impl_.type_id_; } inline uint32_t SetToDefault::type_id() const { // @@protoc_insertion_point(field_get:pg_query.SetToDefault.type_id) return _internal_type_id(); } inline void SetToDefault::_internal_set_type_id(uint32_t value) { _impl_.type_id_ = value; } inline void SetToDefault::set_type_id(uint32_t value) { _internal_set_type_id(value); // @@protoc_insertion_point(field_set:pg_query.SetToDefault.type_id) } // int32 type_mod = 3 [json_name = "typeMod"]; inline void SetToDefault::clear_type_mod() { _impl_.type_mod_ = 0; } inline int32_t SetToDefault::_internal_type_mod() const { return _impl_.type_mod_; } inline int32_t SetToDefault::type_mod() const { // @@protoc_insertion_point(field_get:pg_query.SetToDefault.type_mod) return _internal_type_mod(); } inline void SetToDefault::_internal_set_type_mod(int32_t value) { _impl_.type_mod_ = value; } inline void SetToDefault::set_type_mod(int32_t value) { _internal_set_type_mod(value); // @@protoc_insertion_point(field_set:pg_query.SetToDefault.type_mod) } // uint32 collation = 4 [json_name = "collation"]; inline void SetToDefault::clear_collation() { _impl_.collation_ = 0u; } inline uint32_t SetToDefault::_internal_collation() const { return _impl_.collation_; } inline uint32_t SetToDefault::collation() const { // @@protoc_insertion_point(field_get:pg_query.SetToDefault.collation) return _internal_collation(); } inline void SetToDefault::_internal_set_collation(uint32_t value) { _impl_.collation_ = value; } inline void SetToDefault::set_collation(uint32_t value) { _internal_set_collation(value); // @@protoc_insertion_point(field_set:pg_query.SetToDefault.collation) } // int32 location = 5 [json_name = "location"]; inline void SetToDefault::clear_location() { _impl_.location_ = 0; } inline int32_t SetToDefault::_internal_location() const { return _impl_.location_; } inline int32_t SetToDefault::location() const { // @@protoc_insertion_point(field_get:pg_query.SetToDefault.location) return _internal_location(); } inline void SetToDefault::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void SetToDefault::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.SetToDefault.location) } // ------------------------------------------------------------------- // CurrentOfExpr // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool CurrentOfExpr::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool CurrentOfExpr::has_xpr() const { return _internal_has_xpr(); } inline void CurrentOfExpr::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& CurrentOfExpr::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& CurrentOfExpr::xpr() const { // @@protoc_insertion_point(field_get:pg_query.CurrentOfExpr.xpr) return _internal_xpr(); } inline void CurrentOfExpr::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CurrentOfExpr.xpr) } inline ::pg_query::Node* CurrentOfExpr::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* CurrentOfExpr::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.CurrentOfExpr.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* CurrentOfExpr::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* CurrentOfExpr::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.CurrentOfExpr.xpr) } // uint32 cvarno = 2 [json_name = "cvarno"]; inline void CurrentOfExpr::clear_cvarno() { _impl_.cvarno_ = 0u; } inline uint32_t CurrentOfExpr::_internal_cvarno() const { return _impl_.cvarno_; } inline uint32_t CurrentOfExpr::cvarno() const { // @@protoc_insertion_point(field_get:pg_query.CurrentOfExpr.cvarno) return _internal_cvarno(); } inline void CurrentOfExpr::_internal_set_cvarno(uint32_t value) { _impl_.cvarno_ = value; } inline void CurrentOfExpr::set_cvarno(uint32_t value) { _internal_set_cvarno(value); // @@protoc_insertion_point(field_set:pg_query.CurrentOfExpr.cvarno) } // string cursor_name = 3 [json_name = "cursor_name"]; inline void CurrentOfExpr::clear_cursor_name() { _impl_.cursor_name_.ClearToEmpty(); } inline const std::string& CurrentOfExpr::cursor_name() const { // @@protoc_insertion_point(field_get:pg_query.CurrentOfExpr.cursor_name) return _internal_cursor_name(); } template inline PROTOBUF_ALWAYS_INLINE void CurrentOfExpr::set_cursor_name(ArgT0&& arg0, ArgT... args) { _impl_.cursor_name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CurrentOfExpr.cursor_name) } inline std::string* CurrentOfExpr::mutable_cursor_name() { 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 { return _impl_.cursor_name_.Get(); } inline void CurrentOfExpr::_internal_set_cursor_name(const std::string& value) { _impl_.cursor_name_.Set(value, GetArenaForAllocation()); } inline std::string* CurrentOfExpr::_internal_mutable_cursor_name() { return _impl_.cursor_name_.Mutable(GetArenaForAllocation()); } inline std::string* CurrentOfExpr::release_cursor_name() { // @@protoc_insertion_point(field_release:pg_query.CurrentOfExpr.cursor_name) return _impl_.cursor_name_.Release(); } inline void CurrentOfExpr::set_allocated_cursor_name(std::string* cursor_name) { if (cursor_name != nullptr) { } else { } _impl_.cursor_name_.SetAllocated(cursor_name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.cursor_name_.IsDefault()) { _impl_.cursor_name_.Set("", GetArenaForAllocation()); } #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() { _impl_.cursor_param_ = 0; } inline int32_t CurrentOfExpr::_internal_cursor_param() const { return _impl_.cursor_param_; } inline int32_t CurrentOfExpr::cursor_param() const { // @@protoc_insertion_point(field_get:pg_query.CurrentOfExpr.cursor_param) return _internal_cursor_param(); } inline void CurrentOfExpr::_internal_set_cursor_param(int32_t value) { _impl_.cursor_param_ = value; } inline void CurrentOfExpr::set_cursor_param(int32_t value) { _internal_set_cursor_param(value); // @@protoc_insertion_point(field_set:pg_query.CurrentOfExpr.cursor_param) } // ------------------------------------------------------------------- // NextValueExpr // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool NextValueExpr::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool NextValueExpr::has_xpr() const { return _internal_has_xpr(); } inline void NextValueExpr::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& NextValueExpr::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& NextValueExpr::xpr() const { // @@protoc_insertion_point(field_get:pg_query.NextValueExpr.xpr) return _internal_xpr(); } inline void NextValueExpr::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.NextValueExpr.xpr) } inline ::pg_query::Node* NextValueExpr::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* NextValueExpr::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.NextValueExpr.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* NextValueExpr::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* NextValueExpr::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.NextValueExpr.xpr) } // uint32 seqid = 2 [json_name = "seqid"]; inline void NextValueExpr::clear_seqid() { _impl_.seqid_ = 0u; } inline uint32_t NextValueExpr::_internal_seqid() const { return _impl_.seqid_; } inline uint32_t NextValueExpr::seqid() const { // @@protoc_insertion_point(field_get:pg_query.NextValueExpr.seqid) return _internal_seqid(); } inline void NextValueExpr::_internal_set_seqid(uint32_t value) { _impl_.seqid_ = value; } inline void NextValueExpr::set_seqid(uint32_t value) { _internal_set_seqid(value); // @@protoc_insertion_point(field_set:pg_query.NextValueExpr.seqid) } // uint32 type_id = 3 [json_name = "typeId"]; inline void NextValueExpr::clear_type_id() { _impl_.type_id_ = 0u; } inline uint32_t NextValueExpr::_internal_type_id() const { return _impl_.type_id_; } inline uint32_t NextValueExpr::type_id() const { // @@protoc_insertion_point(field_get:pg_query.NextValueExpr.type_id) return _internal_type_id(); } inline void NextValueExpr::_internal_set_type_id(uint32_t value) { _impl_.type_id_ = value; } inline void NextValueExpr::set_type_id(uint32_t value) { _internal_set_type_id(value); // @@protoc_insertion_point(field_set:pg_query.NextValueExpr.type_id) } // ------------------------------------------------------------------- // InferenceElem // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool InferenceElem::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool InferenceElem::has_xpr() const { return _internal_has_xpr(); } inline void InferenceElem::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& InferenceElem::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& InferenceElem::xpr() const { // @@protoc_insertion_point(field_get:pg_query.InferenceElem.xpr) return _internal_xpr(); } inline void InferenceElem::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.InferenceElem.xpr) } inline ::pg_query::Node* InferenceElem::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* InferenceElem::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.InferenceElem.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* InferenceElem::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* InferenceElem::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.InferenceElem.xpr) } // .pg_query.Node expr = 2 [json_name = "expr"]; inline bool InferenceElem::_internal_has_expr() const { return this != internal_default_instance() && _impl_.expr_ != nullptr; } inline bool InferenceElem::has_expr() const { return _internal_has_expr(); } inline void InferenceElem::clear_expr() { if (GetArenaForAllocation() == nullptr && _impl_.expr_ != nullptr) { delete _impl_.expr_; } _impl_.expr_ = nullptr; } inline const ::pg_query::Node& InferenceElem::_internal_expr() const { const ::pg_query::Node* p = _impl_.expr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& InferenceElem::expr() const { // @@protoc_insertion_point(field_get:pg_query.InferenceElem.expr) return _internal_expr(); } inline void InferenceElem::unsafe_arena_set_allocated_expr( ::pg_query::Node* expr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.expr_); } _impl_.expr_ = expr; if (expr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.InferenceElem.expr) } inline ::pg_query::Node* InferenceElem::release_expr() { ::pg_query::Node* temp = _impl_.expr_; _impl_.expr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* InferenceElem::unsafe_arena_release_expr() { // @@protoc_insertion_point(field_release:pg_query.InferenceElem.expr) ::pg_query::Node* temp = _impl_.expr_; _impl_.expr_ = nullptr; return temp; } inline ::pg_query::Node* InferenceElem::_internal_mutable_expr() { if (_impl_.expr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.expr_ = p; } return _impl_.expr_; } inline ::pg_query::Node* InferenceElem::mutable_expr() { ::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* expr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.expr_; } if (expr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(expr); if (message_arena != submessage_arena) { expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, expr, submessage_arena); } } else { } _impl_.expr_ = expr; // @@protoc_insertion_point(field_set_allocated:pg_query.InferenceElem.expr) } // uint32 infercollid = 3 [json_name = "infercollid"]; inline void InferenceElem::clear_infercollid() { _impl_.infercollid_ = 0u; } inline uint32_t InferenceElem::_internal_infercollid() const { return _impl_.infercollid_; } inline uint32_t InferenceElem::infercollid() const { // @@protoc_insertion_point(field_get:pg_query.InferenceElem.infercollid) return _internal_infercollid(); } inline void InferenceElem::_internal_set_infercollid(uint32_t value) { _impl_.infercollid_ = value; } inline void InferenceElem::set_infercollid(uint32_t value) { _internal_set_infercollid(value); // @@protoc_insertion_point(field_set:pg_query.InferenceElem.infercollid) } // uint32 inferopclass = 4 [json_name = "inferopclass"]; inline void InferenceElem::clear_inferopclass() { _impl_.inferopclass_ = 0u; } inline uint32_t InferenceElem::_internal_inferopclass() const { return _impl_.inferopclass_; } inline uint32_t InferenceElem::inferopclass() const { // @@protoc_insertion_point(field_get:pg_query.InferenceElem.inferopclass) return _internal_inferopclass(); } inline void InferenceElem::_internal_set_inferopclass(uint32_t value) { _impl_.inferopclass_ = value; } inline void InferenceElem::set_inferopclass(uint32_t value) { _internal_set_inferopclass(value); // @@protoc_insertion_point(field_set:pg_query.InferenceElem.inferopclass) } // ------------------------------------------------------------------- // TargetEntry // .pg_query.Node xpr = 1 [json_name = "xpr"]; inline bool TargetEntry::_internal_has_xpr() const { return this != internal_default_instance() && _impl_.xpr_ != nullptr; } inline bool TargetEntry::has_xpr() const { return _internal_has_xpr(); } inline void TargetEntry::clear_xpr() { if (GetArenaForAllocation() == nullptr && _impl_.xpr_ != nullptr) { delete _impl_.xpr_; } _impl_.xpr_ = nullptr; } inline const ::pg_query::Node& TargetEntry::_internal_xpr() const { const ::pg_query::Node* p = _impl_.xpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& TargetEntry::xpr() const { // @@protoc_insertion_point(field_get:pg_query.TargetEntry.xpr) return _internal_xpr(); } inline void TargetEntry::unsafe_arena_set_allocated_xpr( ::pg_query::Node* xpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xpr_); } _impl_.xpr_ = xpr; if (xpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.TargetEntry.xpr) } inline ::pg_query::Node* TargetEntry::release_xpr() { ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* TargetEntry::unsafe_arena_release_xpr() { // @@protoc_insertion_point(field_release:pg_query.TargetEntry.xpr) ::pg_query::Node* temp = _impl_.xpr_; _impl_.xpr_ = nullptr; return temp; } inline ::pg_query::Node* TargetEntry::_internal_mutable_xpr() { if (_impl_.xpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.xpr_ = p; } return _impl_.xpr_; } inline ::pg_query::Node* TargetEntry::mutable_xpr() { ::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* xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.xpr_; } if (xpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(xpr); if (message_arena != submessage_arena) { xpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, xpr, submessage_arena); } } else { } _impl_.xpr_ = xpr; // @@protoc_insertion_point(field_set_allocated:pg_query.TargetEntry.xpr) } // .pg_query.Node expr = 2 [json_name = "expr"]; inline bool TargetEntry::_internal_has_expr() const { return this != internal_default_instance() && _impl_.expr_ != nullptr; } inline bool TargetEntry::has_expr() const { return _internal_has_expr(); } inline void TargetEntry::clear_expr() { if (GetArenaForAllocation() == nullptr && _impl_.expr_ != nullptr) { delete _impl_.expr_; } _impl_.expr_ = nullptr; } inline const ::pg_query::Node& TargetEntry::_internal_expr() const { const ::pg_query::Node* p = _impl_.expr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& TargetEntry::expr() const { // @@protoc_insertion_point(field_get:pg_query.TargetEntry.expr) return _internal_expr(); } inline void TargetEntry::unsafe_arena_set_allocated_expr( ::pg_query::Node* expr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.expr_); } _impl_.expr_ = expr; if (expr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.TargetEntry.expr) } inline ::pg_query::Node* TargetEntry::release_expr() { ::pg_query::Node* temp = _impl_.expr_; _impl_.expr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* TargetEntry::unsafe_arena_release_expr() { // @@protoc_insertion_point(field_release:pg_query.TargetEntry.expr) ::pg_query::Node* temp = _impl_.expr_; _impl_.expr_ = nullptr; return temp; } inline ::pg_query::Node* TargetEntry::_internal_mutable_expr() { if (_impl_.expr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.expr_ = p; } return _impl_.expr_; } inline ::pg_query::Node* TargetEntry::mutable_expr() { ::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* expr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.expr_; } if (expr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(expr); if (message_arena != submessage_arena) { expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, expr, submessage_arena); } } else { } _impl_.expr_ = expr; // @@protoc_insertion_point(field_set_allocated:pg_query.TargetEntry.expr) } // int32 resno = 3 [json_name = "resno"]; inline void TargetEntry::clear_resno() { _impl_.resno_ = 0; } inline int32_t TargetEntry::_internal_resno() const { return _impl_.resno_; } inline int32_t TargetEntry::resno() const { // @@protoc_insertion_point(field_get:pg_query.TargetEntry.resno) return _internal_resno(); } inline void TargetEntry::_internal_set_resno(int32_t value) { _impl_.resno_ = value; } inline void TargetEntry::set_resno(int32_t value) { _internal_set_resno(value); // @@protoc_insertion_point(field_set:pg_query.TargetEntry.resno) } // string resname = 4 [json_name = "resname"]; inline void TargetEntry::clear_resname() { _impl_.resname_.ClearToEmpty(); } inline const std::string& TargetEntry::resname() const { // @@protoc_insertion_point(field_get:pg_query.TargetEntry.resname) return _internal_resname(); } template inline PROTOBUF_ALWAYS_INLINE void TargetEntry::set_resname(ArgT0&& arg0, ArgT... args) { _impl_.resname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.TargetEntry.resname) } inline std::string* TargetEntry::mutable_resname() { 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 { return _impl_.resname_.Get(); } inline void TargetEntry::_internal_set_resname(const std::string& value) { _impl_.resname_.Set(value, GetArenaForAllocation()); } inline std::string* TargetEntry::_internal_mutable_resname() { return _impl_.resname_.Mutable(GetArenaForAllocation()); } inline std::string* TargetEntry::release_resname() { // @@protoc_insertion_point(field_release:pg_query.TargetEntry.resname) return _impl_.resname_.Release(); } inline void TargetEntry::set_allocated_resname(std::string* resname) { if (resname != nullptr) { } else { } _impl_.resname_.SetAllocated(resname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.resname_.IsDefault()) { _impl_.resname_.Set("", GetArenaForAllocation()); } #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() { _impl_.ressortgroupref_ = 0u; } inline uint32_t TargetEntry::_internal_ressortgroupref() const { return _impl_.ressortgroupref_; } inline uint32_t TargetEntry::ressortgroupref() const { // @@protoc_insertion_point(field_get:pg_query.TargetEntry.ressortgroupref) return _internal_ressortgroupref(); } inline void TargetEntry::_internal_set_ressortgroupref(uint32_t value) { _impl_.ressortgroupref_ = value; } inline void TargetEntry::set_ressortgroupref(uint32_t value) { _internal_set_ressortgroupref(value); // @@protoc_insertion_point(field_set:pg_query.TargetEntry.ressortgroupref) } // uint32 resorigtbl = 6 [json_name = "resorigtbl"]; inline void TargetEntry::clear_resorigtbl() { _impl_.resorigtbl_ = 0u; } inline uint32_t TargetEntry::_internal_resorigtbl() const { return _impl_.resorigtbl_; } inline uint32_t TargetEntry::resorigtbl() const { // @@protoc_insertion_point(field_get:pg_query.TargetEntry.resorigtbl) return _internal_resorigtbl(); } inline void TargetEntry::_internal_set_resorigtbl(uint32_t value) { _impl_.resorigtbl_ = value; } inline void TargetEntry::set_resorigtbl(uint32_t value) { _internal_set_resorigtbl(value); // @@protoc_insertion_point(field_set:pg_query.TargetEntry.resorigtbl) } // int32 resorigcol = 7 [json_name = "resorigcol"]; inline void TargetEntry::clear_resorigcol() { _impl_.resorigcol_ = 0; } inline int32_t TargetEntry::_internal_resorigcol() const { return _impl_.resorigcol_; } inline int32_t TargetEntry::resorigcol() const { // @@protoc_insertion_point(field_get:pg_query.TargetEntry.resorigcol) return _internal_resorigcol(); } inline void TargetEntry::_internal_set_resorigcol(int32_t value) { _impl_.resorigcol_ = value; } inline void TargetEntry::set_resorigcol(int32_t value) { _internal_set_resorigcol(value); // @@protoc_insertion_point(field_set:pg_query.TargetEntry.resorigcol) } // bool resjunk = 8 [json_name = "resjunk"]; inline void TargetEntry::clear_resjunk() { _impl_.resjunk_ = false; } inline bool TargetEntry::_internal_resjunk() const { return _impl_.resjunk_; } inline bool TargetEntry::resjunk() const { // @@protoc_insertion_point(field_get:pg_query.TargetEntry.resjunk) return _internal_resjunk(); } inline void TargetEntry::_internal_set_resjunk(bool value) { _impl_.resjunk_ = value; } inline void TargetEntry::set_resjunk(bool value) { _internal_set_resjunk(value); // @@protoc_insertion_point(field_set:pg_query.TargetEntry.resjunk) } // ------------------------------------------------------------------- // RangeTblRef // int32 rtindex = 1 [json_name = "rtindex"]; inline void RangeTblRef::clear_rtindex() { _impl_.rtindex_ = 0; } inline int32_t RangeTblRef::_internal_rtindex() const { return _impl_.rtindex_; } inline int32_t RangeTblRef::rtindex() const { // @@protoc_insertion_point(field_get:pg_query.RangeTblRef.rtindex) return _internal_rtindex(); } inline void RangeTblRef::_internal_set_rtindex(int32_t value) { _impl_.rtindex_ = value; } inline void RangeTblRef::set_rtindex(int32_t value) { _internal_set_rtindex(value); // @@protoc_insertion_point(field_set:pg_query.RangeTblRef.rtindex) } // ------------------------------------------------------------------- // JoinExpr // .pg_query.JoinType jointype = 1 [json_name = "jointype"]; inline void JoinExpr::clear_jointype() { _impl_.jointype_ = 0; } inline ::pg_query::JoinType JoinExpr::_internal_jointype() const { return static_cast< ::pg_query::JoinType >(_impl_.jointype_); } inline ::pg_query::JoinType JoinExpr::jointype() const { // @@protoc_insertion_point(field_get:pg_query.JoinExpr.jointype) return _internal_jointype(); } inline void JoinExpr::_internal_set_jointype(::pg_query::JoinType value) { _impl_.jointype_ = value; } inline void JoinExpr::set_jointype(::pg_query::JoinType value) { _internal_set_jointype(value); // @@protoc_insertion_point(field_set:pg_query.JoinExpr.jointype) } // bool is_natural = 2 [json_name = "isNatural"]; inline void JoinExpr::clear_is_natural() { _impl_.is_natural_ = false; } inline bool JoinExpr::_internal_is_natural() const { return _impl_.is_natural_; } inline bool JoinExpr::is_natural() const { // @@protoc_insertion_point(field_get:pg_query.JoinExpr.is_natural) return _internal_is_natural(); } inline void JoinExpr::_internal_set_is_natural(bool value) { _impl_.is_natural_ = value; } inline void JoinExpr::set_is_natural(bool value) { _internal_set_is_natural(value); // @@protoc_insertion_point(field_set:pg_query.JoinExpr.is_natural) } // .pg_query.Node larg = 3 [json_name = "larg"]; inline bool JoinExpr::_internal_has_larg() const { return this != internal_default_instance() && _impl_.larg_ != nullptr; } inline bool JoinExpr::has_larg() const { return _internal_has_larg(); } inline void JoinExpr::clear_larg() { if (GetArenaForAllocation() == nullptr && _impl_.larg_ != nullptr) { delete _impl_.larg_; } _impl_.larg_ = nullptr; } inline const ::pg_query::Node& JoinExpr::_internal_larg() const { const ::pg_query::Node* p = _impl_.larg_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& JoinExpr::larg() const { // @@protoc_insertion_point(field_get:pg_query.JoinExpr.larg) return _internal_larg(); } inline void JoinExpr::unsafe_arena_set_allocated_larg( ::pg_query::Node* larg) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.larg_); } _impl_.larg_ = larg; if (larg) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JoinExpr.larg) } inline ::pg_query::Node* JoinExpr::release_larg() { ::pg_query::Node* temp = _impl_.larg_; _impl_.larg_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* JoinExpr::unsafe_arena_release_larg() { // @@protoc_insertion_point(field_release:pg_query.JoinExpr.larg) ::pg_query::Node* temp = _impl_.larg_; _impl_.larg_ = nullptr; return temp; } inline ::pg_query::Node* JoinExpr::_internal_mutable_larg() { if (_impl_.larg_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.larg_ = p; } return _impl_.larg_; } inline ::pg_query::Node* JoinExpr::mutable_larg() { ::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* larg) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.larg_; } if (larg) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(larg); if (message_arena != submessage_arena) { larg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, larg, submessage_arena); } } else { } _impl_.larg_ = larg; // @@protoc_insertion_point(field_set_allocated:pg_query.JoinExpr.larg) } // .pg_query.Node rarg = 4 [json_name = "rarg"]; inline bool JoinExpr::_internal_has_rarg() const { return this != internal_default_instance() && _impl_.rarg_ != nullptr; } inline bool JoinExpr::has_rarg() const { return _internal_has_rarg(); } inline void JoinExpr::clear_rarg() { if (GetArenaForAllocation() == nullptr && _impl_.rarg_ != nullptr) { delete _impl_.rarg_; } _impl_.rarg_ = nullptr; } inline const ::pg_query::Node& JoinExpr::_internal_rarg() const { const ::pg_query::Node* p = _impl_.rarg_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& JoinExpr::rarg() const { // @@protoc_insertion_point(field_get:pg_query.JoinExpr.rarg) return _internal_rarg(); } inline void JoinExpr::unsafe_arena_set_allocated_rarg( ::pg_query::Node* rarg) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.rarg_); } _impl_.rarg_ = rarg; if (rarg) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JoinExpr.rarg) } inline ::pg_query::Node* JoinExpr::release_rarg() { ::pg_query::Node* temp = _impl_.rarg_; _impl_.rarg_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* JoinExpr::unsafe_arena_release_rarg() { // @@protoc_insertion_point(field_release:pg_query.JoinExpr.rarg) ::pg_query::Node* temp = _impl_.rarg_; _impl_.rarg_ = nullptr; return temp; } inline ::pg_query::Node* JoinExpr::_internal_mutable_rarg() { if (_impl_.rarg_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.rarg_ = p; } return _impl_.rarg_; } inline ::pg_query::Node* JoinExpr::mutable_rarg() { ::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* rarg) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.rarg_; } if (rarg) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(rarg); if (message_arena != submessage_arena) { rarg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, rarg, submessage_arena); } } else { } _impl_.rarg_ = rarg; // @@protoc_insertion_point(field_set_allocated:pg_query.JoinExpr.rarg) } // repeated .pg_query.Node using_clause = 5 [json_name = "usingClause"]; inline int JoinExpr::_internal_using_clause_size() const { return _impl_.using_clause_.size(); } inline int JoinExpr::using_clause_size() const { return _internal_using_clause_size(); } inline void JoinExpr::clear_using_clause() { _impl_.using_clause_.Clear(); } inline ::pg_query::Node* JoinExpr::mutable_using_clause(int index) { // @@protoc_insertion_point(field_mutable:pg_query.JoinExpr.using_clause) return _impl_.using_clause_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* JoinExpr::mutable_using_clause() { // @@protoc_insertion_point(field_mutable_list:pg_query.JoinExpr.using_clause) return &_impl_.using_clause_; } inline const ::pg_query::Node& JoinExpr::_internal_using_clause(int index) const { return _impl_.using_clause_.Get(index); } inline const ::pg_query::Node& JoinExpr::using_clause(int index) const { // @@protoc_insertion_point(field_get:pg_query.JoinExpr.using_clause) return _internal_using_clause(index); } inline ::pg_query::Node* JoinExpr::_internal_add_using_clause() { return _impl_.using_clause_.Add(); } inline ::pg_query::Node* JoinExpr::add_using_clause() { ::pg_query::Node* _add = _internal_add_using_clause(); // @@protoc_insertion_point(field_add:pg_query.JoinExpr.using_clause) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& JoinExpr::using_clause() const { // @@protoc_insertion_point(field_list:pg_query.JoinExpr.using_clause) return _impl_.using_clause_; } // .pg_query.Alias join_using_alias = 6 [json_name = "join_using_alias"]; inline bool JoinExpr::_internal_has_join_using_alias() const { return this != internal_default_instance() && _impl_.join_using_alias_ != nullptr; } inline bool JoinExpr::has_join_using_alias() const { return _internal_has_join_using_alias(); } inline void JoinExpr::clear_join_using_alias() { if (GetArenaForAllocation() == nullptr && _impl_.join_using_alias_ != nullptr) { delete _impl_.join_using_alias_; } _impl_.join_using_alias_ = nullptr; } inline const ::pg_query::Alias& JoinExpr::_internal_join_using_alias() const { const ::pg_query::Alias* p = _impl_.join_using_alias_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Alias_default_instance_); } inline const ::pg_query::Alias& JoinExpr::join_using_alias() const { // @@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* join_using_alias) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.join_using_alias_); } _impl_.join_using_alias_ = join_using_alias; if (join_using_alias) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JoinExpr.join_using_alias) } inline ::pg_query::Alias* JoinExpr::release_join_using_alias() { ::pg_query::Alias* temp = _impl_.join_using_alias_; _impl_.join_using_alias_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Alias* JoinExpr::unsafe_arena_release_join_using_alias() { // @@protoc_insertion_point(field_release:pg_query.JoinExpr.join_using_alias) ::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() { if (_impl_.join_using_alias_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Alias>(GetArenaForAllocation()); _impl_.join_using_alias_ = p; } return _impl_.join_using_alias_; } inline ::pg_query::Alias* JoinExpr::mutable_join_using_alias() { ::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* join_using_alias) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.join_using_alias_; } if (join_using_alias) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(join_using_alias); if (message_arena != submessage_arena) { join_using_alias = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, join_using_alias, submessage_arena); } } else { } _impl_.join_using_alias_ = join_using_alias; // @@protoc_insertion_point(field_set_allocated:pg_query.JoinExpr.join_using_alias) } // .pg_query.Node quals = 7 [json_name = "quals"]; inline bool JoinExpr::_internal_has_quals() const { return this != internal_default_instance() && _impl_.quals_ != nullptr; } inline bool JoinExpr::has_quals() const { return _internal_has_quals(); } inline void JoinExpr::clear_quals() { if (GetArenaForAllocation() == nullptr && _impl_.quals_ != nullptr) { delete _impl_.quals_; } _impl_.quals_ = nullptr; } inline const ::pg_query::Node& JoinExpr::_internal_quals() const { const ::pg_query::Node* p = _impl_.quals_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& JoinExpr::quals() const { // @@protoc_insertion_point(field_get:pg_query.JoinExpr.quals) return _internal_quals(); } inline void JoinExpr::unsafe_arena_set_allocated_quals( ::pg_query::Node* quals) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quals_); } _impl_.quals_ = quals; if (quals) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JoinExpr.quals) } inline ::pg_query::Node* JoinExpr::release_quals() { ::pg_query::Node* temp = _impl_.quals_; _impl_.quals_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* JoinExpr::unsafe_arena_release_quals() { // @@protoc_insertion_point(field_release:pg_query.JoinExpr.quals) ::pg_query::Node* temp = _impl_.quals_; _impl_.quals_ = nullptr; return temp; } inline ::pg_query::Node* JoinExpr::_internal_mutable_quals() { if (_impl_.quals_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.quals_ = p; } return _impl_.quals_; } inline ::pg_query::Node* JoinExpr::mutable_quals() { ::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* quals) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.quals_; } if (quals) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quals); if (message_arena != submessage_arena) { quals = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, quals, submessage_arena); } } else { } _impl_.quals_ = quals; // @@protoc_insertion_point(field_set_allocated:pg_query.JoinExpr.quals) } // .pg_query.Alias alias = 8 [json_name = "alias"]; inline bool JoinExpr::_internal_has_alias() const { return this != internal_default_instance() && _impl_.alias_ != nullptr; } inline bool JoinExpr::has_alias() const { return _internal_has_alias(); } inline void JoinExpr::clear_alias() { if (GetArenaForAllocation() == nullptr && _impl_.alias_ != nullptr) { delete _impl_.alias_; } _impl_.alias_ = nullptr; } inline const ::pg_query::Alias& JoinExpr::_internal_alias() const { const ::pg_query::Alias* p = _impl_.alias_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Alias_default_instance_); } inline const ::pg_query::Alias& JoinExpr::alias() const { // @@protoc_insertion_point(field_get:pg_query.JoinExpr.alias) return _internal_alias(); } inline void JoinExpr::unsafe_arena_set_allocated_alias( ::pg_query::Alias* alias) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.alias_); } _impl_.alias_ = alias; if (alias) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.JoinExpr.alias) } inline ::pg_query::Alias* JoinExpr::release_alias() { ::pg_query::Alias* temp = _impl_.alias_; _impl_.alias_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Alias* JoinExpr::unsafe_arena_release_alias() { // @@protoc_insertion_point(field_release:pg_query.JoinExpr.alias) ::pg_query::Alias* temp = _impl_.alias_; _impl_.alias_ = nullptr; return temp; } inline ::pg_query::Alias* JoinExpr::_internal_mutable_alias() { if (_impl_.alias_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Alias>(GetArenaForAllocation()); _impl_.alias_ = p; } return _impl_.alias_; } inline ::pg_query::Alias* JoinExpr::mutable_alias() { ::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* alias) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.alias_; } if (alias) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(alias); if (message_arena != submessage_arena) { alias = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, alias, submessage_arena); } } else { } _impl_.alias_ = alias; // @@protoc_insertion_point(field_set_allocated:pg_query.JoinExpr.alias) } // int32 rtindex = 9 [json_name = "rtindex"]; inline void JoinExpr::clear_rtindex() { _impl_.rtindex_ = 0; } inline int32_t JoinExpr::_internal_rtindex() const { return _impl_.rtindex_; } inline int32_t JoinExpr::rtindex() const { // @@protoc_insertion_point(field_get:pg_query.JoinExpr.rtindex) return _internal_rtindex(); } inline void JoinExpr::_internal_set_rtindex(int32_t value) { _impl_.rtindex_ = value; } inline void JoinExpr::set_rtindex(int32_t value) { _internal_set_rtindex(value); // @@protoc_insertion_point(field_set:pg_query.JoinExpr.rtindex) } // ------------------------------------------------------------------- // FromExpr // repeated .pg_query.Node fromlist = 1 [json_name = "fromlist"]; inline int FromExpr::_internal_fromlist_size() const { return _impl_.fromlist_.size(); } inline int FromExpr::fromlist_size() const { return _internal_fromlist_size(); } inline void FromExpr::clear_fromlist() { _impl_.fromlist_.Clear(); } inline ::pg_query::Node* FromExpr::mutable_fromlist(int index) { // @@protoc_insertion_point(field_mutable:pg_query.FromExpr.fromlist) return _impl_.fromlist_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* FromExpr::mutable_fromlist() { // @@protoc_insertion_point(field_mutable_list:pg_query.FromExpr.fromlist) return &_impl_.fromlist_; } inline const ::pg_query::Node& FromExpr::_internal_fromlist(int index) const { return _impl_.fromlist_.Get(index); } inline const ::pg_query::Node& FromExpr::fromlist(int index) const { // @@protoc_insertion_point(field_get:pg_query.FromExpr.fromlist) return _internal_fromlist(index); } inline ::pg_query::Node* FromExpr::_internal_add_fromlist() { return _impl_.fromlist_.Add(); } inline ::pg_query::Node* FromExpr::add_fromlist() { ::pg_query::Node* _add = _internal_add_fromlist(); // @@protoc_insertion_point(field_add:pg_query.FromExpr.fromlist) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& FromExpr::fromlist() const { // @@protoc_insertion_point(field_list:pg_query.FromExpr.fromlist) return _impl_.fromlist_; } // .pg_query.Node quals = 2 [json_name = "quals"]; inline bool FromExpr::_internal_has_quals() const { return this != internal_default_instance() && _impl_.quals_ != nullptr; } inline bool FromExpr::has_quals() const { return _internal_has_quals(); } inline void FromExpr::clear_quals() { if (GetArenaForAllocation() == nullptr && _impl_.quals_ != nullptr) { delete _impl_.quals_; } _impl_.quals_ = nullptr; } inline const ::pg_query::Node& FromExpr::_internal_quals() const { const ::pg_query::Node* p = _impl_.quals_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& FromExpr::quals() const { // @@protoc_insertion_point(field_get:pg_query.FromExpr.quals) return _internal_quals(); } inline void FromExpr::unsafe_arena_set_allocated_quals( ::pg_query::Node* quals) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quals_); } _impl_.quals_ = quals; if (quals) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FromExpr.quals) } inline ::pg_query::Node* FromExpr::release_quals() { ::pg_query::Node* temp = _impl_.quals_; _impl_.quals_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* FromExpr::unsafe_arena_release_quals() { // @@protoc_insertion_point(field_release:pg_query.FromExpr.quals) ::pg_query::Node* temp = _impl_.quals_; _impl_.quals_ = nullptr; return temp; } inline ::pg_query::Node* FromExpr::_internal_mutable_quals() { if (_impl_.quals_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.quals_ = p; } return _impl_.quals_; } inline ::pg_query::Node* FromExpr::mutable_quals() { ::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* quals) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.quals_; } if (quals) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quals); if (message_arena != submessage_arena) { quals = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, quals, submessage_arena); } } else { } _impl_.quals_ = quals; // @@protoc_insertion_point(field_set_allocated:pg_query.FromExpr.quals) } // ------------------------------------------------------------------- // OnConflictExpr // .pg_query.OnConflictAction action = 1 [json_name = "action"]; inline void OnConflictExpr::clear_action() { _impl_.action_ = 0; } inline ::pg_query::OnConflictAction OnConflictExpr::_internal_action() const { return static_cast< ::pg_query::OnConflictAction >(_impl_.action_); } inline ::pg_query::OnConflictAction OnConflictExpr::action() const { // @@protoc_insertion_point(field_get:pg_query.OnConflictExpr.action) return _internal_action(); } inline void OnConflictExpr::_internal_set_action(::pg_query::OnConflictAction value) { _impl_.action_ = value; } inline void OnConflictExpr::set_action(::pg_query::OnConflictAction value) { _internal_set_action(value); // @@protoc_insertion_point(field_set:pg_query.OnConflictExpr.action) } // repeated .pg_query.Node arbiter_elems = 2 [json_name = "arbiterElems"]; inline int OnConflictExpr::_internal_arbiter_elems_size() const { return _impl_.arbiter_elems_.size(); } inline int OnConflictExpr::arbiter_elems_size() const { return _internal_arbiter_elems_size(); } inline void OnConflictExpr::clear_arbiter_elems() { _impl_.arbiter_elems_.Clear(); } inline ::pg_query::Node* OnConflictExpr::mutable_arbiter_elems(int index) { // @@protoc_insertion_point(field_mutable:pg_query.OnConflictExpr.arbiter_elems) return _impl_.arbiter_elems_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* OnConflictExpr::mutable_arbiter_elems() { // @@protoc_insertion_point(field_mutable_list:pg_query.OnConflictExpr.arbiter_elems) return &_impl_.arbiter_elems_; } inline const ::pg_query::Node& OnConflictExpr::_internal_arbiter_elems(int index) const { return _impl_.arbiter_elems_.Get(index); } inline const ::pg_query::Node& OnConflictExpr::arbiter_elems(int index) const { // @@protoc_insertion_point(field_get:pg_query.OnConflictExpr.arbiter_elems) return _internal_arbiter_elems(index); } inline ::pg_query::Node* OnConflictExpr::_internal_add_arbiter_elems() { return _impl_.arbiter_elems_.Add(); } inline ::pg_query::Node* OnConflictExpr::add_arbiter_elems() { ::pg_query::Node* _add = _internal_add_arbiter_elems(); // @@protoc_insertion_point(field_add:pg_query.OnConflictExpr.arbiter_elems) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& OnConflictExpr::arbiter_elems() const { // @@protoc_insertion_point(field_list:pg_query.OnConflictExpr.arbiter_elems) return _impl_.arbiter_elems_; } // .pg_query.Node arbiter_where = 3 [json_name = "arbiterWhere"]; inline bool OnConflictExpr::_internal_has_arbiter_where() const { return this != internal_default_instance() && _impl_.arbiter_where_ != nullptr; } inline bool OnConflictExpr::has_arbiter_where() const { return _internal_has_arbiter_where(); } inline void OnConflictExpr::clear_arbiter_where() { if (GetArenaForAllocation() == nullptr && _impl_.arbiter_where_ != nullptr) { delete _impl_.arbiter_where_; } _impl_.arbiter_where_ = nullptr; } inline const ::pg_query::Node& OnConflictExpr::_internal_arbiter_where() const { const ::pg_query::Node* p = _impl_.arbiter_where_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& OnConflictExpr::arbiter_where() const { // @@protoc_insertion_point(field_get:pg_query.OnConflictExpr.arbiter_where) return _internal_arbiter_where(); } inline void OnConflictExpr::unsafe_arena_set_allocated_arbiter_where( ::pg_query::Node* arbiter_where) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.arbiter_where_); } _impl_.arbiter_where_ = arbiter_where; if (arbiter_where) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.OnConflictExpr.arbiter_where) } inline ::pg_query::Node* OnConflictExpr::release_arbiter_where() { ::pg_query::Node* temp = _impl_.arbiter_where_; _impl_.arbiter_where_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* OnConflictExpr::unsafe_arena_release_arbiter_where() { // @@protoc_insertion_point(field_release:pg_query.OnConflictExpr.arbiter_where) ::pg_query::Node* temp = _impl_.arbiter_where_; _impl_.arbiter_where_ = nullptr; return temp; } inline ::pg_query::Node* OnConflictExpr::_internal_mutable_arbiter_where() { if (_impl_.arbiter_where_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.arbiter_where_ = p; } return _impl_.arbiter_where_; } inline ::pg_query::Node* OnConflictExpr::mutable_arbiter_where() { ::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* arbiter_where) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.arbiter_where_; } if (arbiter_where) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(arbiter_where); if (message_arena != submessage_arena) { arbiter_where = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, arbiter_where, submessage_arena); } } else { } _impl_.arbiter_where_ = arbiter_where; // @@protoc_insertion_point(field_set_allocated:pg_query.OnConflictExpr.arbiter_where) } // uint32 constraint = 4 [json_name = "constraint"]; inline void OnConflictExpr::clear_constraint() { _impl_.constraint_ = 0u; } inline uint32_t OnConflictExpr::_internal_constraint() const { return _impl_.constraint_; } inline uint32_t OnConflictExpr::constraint() const { // @@protoc_insertion_point(field_get:pg_query.OnConflictExpr.constraint) return _internal_constraint(); } inline void OnConflictExpr::_internal_set_constraint(uint32_t value) { _impl_.constraint_ = value; } inline void OnConflictExpr::set_constraint(uint32_t value) { _internal_set_constraint(value); // @@protoc_insertion_point(field_set:pg_query.OnConflictExpr.constraint) } // repeated .pg_query.Node on_conflict_set = 5 [json_name = "onConflictSet"]; inline int OnConflictExpr::_internal_on_conflict_set_size() const { return _impl_.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() { _impl_.on_conflict_set_.Clear(); } inline ::pg_query::Node* OnConflictExpr::mutable_on_conflict_set(int index) { // @@protoc_insertion_point(field_mutable:pg_query.OnConflictExpr.on_conflict_set) return _impl_.on_conflict_set_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* OnConflictExpr::mutable_on_conflict_set() { // @@protoc_insertion_point(field_mutable_list:pg_query.OnConflictExpr.on_conflict_set) return &_impl_.on_conflict_set_; } inline const ::pg_query::Node& OnConflictExpr::_internal_on_conflict_set(int index) const { return _impl_.on_conflict_set_.Get(index); } inline const ::pg_query::Node& OnConflictExpr::on_conflict_set(int index) const { // @@protoc_insertion_point(field_get:pg_query.OnConflictExpr.on_conflict_set) return _internal_on_conflict_set(index); } inline ::pg_query::Node* OnConflictExpr::_internal_add_on_conflict_set() { return _impl_.on_conflict_set_.Add(); } inline ::pg_query::Node* OnConflictExpr::add_on_conflict_set() { ::pg_query::Node* _add = _internal_add_on_conflict_set(); // @@protoc_insertion_point(field_add:pg_query.OnConflictExpr.on_conflict_set) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& OnConflictExpr::on_conflict_set() const { // @@protoc_insertion_point(field_list:pg_query.OnConflictExpr.on_conflict_set) return _impl_.on_conflict_set_; } // .pg_query.Node on_conflict_where = 6 [json_name = "onConflictWhere"]; inline bool OnConflictExpr::_internal_has_on_conflict_where() const { return this != internal_default_instance() && _impl_.on_conflict_where_ != nullptr; } inline bool OnConflictExpr::has_on_conflict_where() const { return _internal_has_on_conflict_where(); } inline void OnConflictExpr::clear_on_conflict_where() { if (GetArenaForAllocation() == nullptr && _impl_.on_conflict_where_ != nullptr) { delete _impl_.on_conflict_where_; } _impl_.on_conflict_where_ = nullptr; } inline const ::pg_query::Node& OnConflictExpr::_internal_on_conflict_where() const { const ::pg_query::Node* p = _impl_.on_conflict_where_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& OnConflictExpr::on_conflict_where() const { // @@protoc_insertion_point(field_get:pg_query.OnConflictExpr.on_conflict_where) return _internal_on_conflict_where(); } inline void OnConflictExpr::unsafe_arena_set_allocated_on_conflict_where( ::pg_query::Node* on_conflict_where) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.on_conflict_where_); } _impl_.on_conflict_where_ = on_conflict_where; if (on_conflict_where) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.OnConflictExpr.on_conflict_where) } inline ::pg_query::Node* OnConflictExpr::release_on_conflict_where() { ::pg_query::Node* temp = _impl_.on_conflict_where_; _impl_.on_conflict_where_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* OnConflictExpr::unsafe_arena_release_on_conflict_where() { // @@protoc_insertion_point(field_release:pg_query.OnConflictExpr.on_conflict_where) ::pg_query::Node* temp = _impl_.on_conflict_where_; _impl_.on_conflict_where_ = nullptr; return temp; } inline ::pg_query::Node* OnConflictExpr::_internal_mutable_on_conflict_where() { if (_impl_.on_conflict_where_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.on_conflict_where_ = p; } return _impl_.on_conflict_where_; } inline ::pg_query::Node* OnConflictExpr::mutable_on_conflict_where() { ::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* on_conflict_where) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.on_conflict_where_; } if (on_conflict_where) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(on_conflict_where); if (message_arena != submessage_arena) { on_conflict_where = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, on_conflict_where, submessage_arena); } } else { } _impl_.on_conflict_where_ = on_conflict_where; // @@protoc_insertion_point(field_set_allocated:pg_query.OnConflictExpr.on_conflict_where) } // int32 excl_rel_index = 7 [json_name = "exclRelIndex"]; inline void OnConflictExpr::clear_excl_rel_index() { _impl_.excl_rel_index_ = 0; } inline int32_t OnConflictExpr::_internal_excl_rel_index() const { return _impl_.excl_rel_index_; } 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::_internal_set_excl_rel_index(int32_t value) { _impl_.excl_rel_index_ = value; } 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) } // repeated .pg_query.Node excl_rel_tlist = 8 [json_name = "exclRelTlist"]; inline int OnConflictExpr::_internal_excl_rel_tlist_size() const { return _impl_.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() { _impl_.excl_rel_tlist_.Clear(); } inline ::pg_query::Node* OnConflictExpr::mutable_excl_rel_tlist(int index) { // @@protoc_insertion_point(field_mutable:pg_query.OnConflictExpr.excl_rel_tlist) return _impl_.excl_rel_tlist_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* OnConflictExpr::mutable_excl_rel_tlist() { // @@protoc_insertion_point(field_mutable_list:pg_query.OnConflictExpr.excl_rel_tlist) return &_impl_.excl_rel_tlist_; } inline const ::pg_query::Node& OnConflictExpr::_internal_excl_rel_tlist(int index) const { return _impl_.excl_rel_tlist_.Get(index); } inline const ::pg_query::Node& OnConflictExpr::excl_rel_tlist(int index) const { // @@protoc_insertion_point(field_get:pg_query.OnConflictExpr.excl_rel_tlist) return _internal_excl_rel_tlist(index); } inline ::pg_query::Node* OnConflictExpr::_internal_add_excl_rel_tlist() { return _impl_.excl_rel_tlist_.Add(); } inline ::pg_query::Node* OnConflictExpr::add_excl_rel_tlist() { ::pg_query::Node* _add = _internal_add_excl_rel_tlist(); // @@protoc_insertion_point(field_add:pg_query.OnConflictExpr.excl_rel_tlist) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& OnConflictExpr::excl_rel_tlist() const { // @@protoc_insertion_point(field_list:pg_query.OnConflictExpr.excl_rel_tlist) return _impl_.excl_rel_tlist_; } // ------------------------------------------------------------------- // IntoClause // .pg_query.RangeVar rel = 1 [json_name = "rel"]; inline bool IntoClause::_internal_has_rel() const { return this != internal_default_instance() && _impl_.rel_ != nullptr; } inline bool IntoClause::has_rel() const { return _internal_has_rel(); } inline void IntoClause::clear_rel() { if (GetArenaForAllocation() == nullptr && _impl_.rel_ != nullptr) { delete _impl_.rel_; } _impl_.rel_ = nullptr; } inline const ::pg_query::RangeVar& IntoClause::_internal_rel() const { const ::pg_query::RangeVar* p = _impl_.rel_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& IntoClause::rel() const { // @@protoc_insertion_point(field_get:pg_query.IntoClause.rel) return _internal_rel(); } inline void IntoClause::unsafe_arena_set_allocated_rel( ::pg_query::RangeVar* rel) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.rel_); } _impl_.rel_ = rel; if (rel) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.IntoClause.rel) } inline ::pg_query::RangeVar* IntoClause::release_rel() { ::pg_query::RangeVar* temp = _impl_.rel_; _impl_.rel_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* IntoClause::unsafe_arena_release_rel() { // @@protoc_insertion_point(field_release:pg_query.IntoClause.rel) ::pg_query::RangeVar* temp = _impl_.rel_; _impl_.rel_ = nullptr; return temp; } inline ::pg_query::RangeVar* IntoClause::_internal_mutable_rel() { if (_impl_.rel_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.rel_ = p; } return _impl_.rel_; } inline ::pg_query::RangeVar* IntoClause::mutable_rel() { ::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* rel) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.rel_; } if (rel) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(rel); if (message_arena != submessage_arena) { rel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, rel, submessage_arena); } } else { } _impl_.rel_ = rel; // @@protoc_insertion_point(field_set_allocated:pg_query.IntoClause.rel) } // repeated .pg_query.Node col_names = 2 [json_name = "colNames"]; inline int IntoClause::_internal_col_names_size() const { return _impl_.col_names_.size(); } inline int IntoClause::col_names_size() const { return _internal_col_names_size(); } inline void IntoClause::clear_col_names() { _impl_.col_names_.Clear(); } inline ::pg_query::Node* IntoClause::mutable_col_names(int index) { // @@protoc_insertion_point(field_mutable:pg_query.IntoClause.col_names) return _impl_.col_names_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* IntoClause::mutable_col_names() { // @@protoc_insertion_point(field_mutable_list:pg_query.IntoClause.col_names) return &_impl_.col_names_; } inline const ::pg_query::Node& IntoClause::_internal_col_names(int index) const { return _impl_.col_names_.Get(index); } inline const ::pg_query::Node& IntoClause::col_names(int index) const { // @@protoc_insertion_point(field_get:pg_query.IntoClause.col_names) return _internal_col_names(index); } inline ::pg_query::Node* IntoClause::_internal_add_col_names() { return _impl_.col_names_.Add(); } inline ::pg_query::Node* IntoClause::add_col_names() { ::pg_query::Node* _add = _internal_add_col_names(); // @@protoc_insertion_point(field_add:pg_query.IntoClause.col_names) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& IntoClause::col_names() const { // @@protoc_insertion_point(field_list:pg_query.IntoClause.col_names) return _impl_.col_names_; } // string access_method = 3 [json_name = "accessMethod"]; inline void IntoClause::clear_access_method() { _impl_.access_method_.ClearToEmpty(); } inline const std::string& IntoClause::access_method() const { // @@protoc_insertion_point(field_get:pg_query.IntoClause.access_method) return _internal_access_method(); } template inline PROTOBUF_ALWAYS_INLINE void IntoClause::set_access_method(ArgT0&& arg0, ArgT... args) { _impl_.access_method_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.IntoClause.access_method) } inline std::string* IntoClause::mutable_access_method() { 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 { return _impl_.access_method_.Get(); } inline void IntoClause::_internal_set_access_method(const std::string& value) { _impl_.access_method_.Set(value, GetArenaForAllocation()); } inline std::string* IntoClause::_internal_mutable_access_method() { return _impl_.access_method_.Mutable(GetArenaForAllocation()); } inline std::string* IntoClause::release_access_method() { // @@protoc_insertion_point(field_release:pg_query.IntoClause.access_method) return _impl_.access_method_.Release(); } inline void IntoClause::set_allocated_access_method(std::string* access_method) { if (access_method != nullptr) { } else { } _impl_.access_method_.SetAllocated(access_method, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.access_method_.IsDefault()) { _impl_.access_method_.Set("", GetArenaForAllocation()); } #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 _impl_.options_.size(); } inline int IntoClause::options_size() const { return _internal_options_size(); } inline void IntoClause::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* IntoClause::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.IntoClause.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* IntoClause::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.IntoClause.options) return &_impl_.options_; } inline const ::pg_query::Node& IntoClause::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& IntoClause::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.IntoClause.options) return _internal_options(index); } inline ::pg_query::Node* IntoClause::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* IntoClause::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.IntoClause.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& IntoClause::options() const { // @@protoc_insertion_point(field_list:pg_query.IntoClause.options) return _impl_.options_; } // .pg_query.OnCommitAction on_commit = 5 [json_name = "onCommit"]; inline void IntoClause::clear_on_commit() { _impl_.on_commit_ = 0; } inline ::pg_query::OnCommitAction IntoClause::_internal_on_commit() const { return static_cast< ::pg_query::OnCommitAction >(_impl_.on_commit_); } inline ::pg_query::OnCommitAction IntoClause::on_commit() const { // @@protoc_insertion_point(field_get:pg_query.IntoClause.on_commit) return _internal_on_commit(); } inline void IntoClause::_internal_set_on_commit(::pg_query::OnCommitAction value) { _impl_.on_commit_ = value; } inline void IntoClause::set_on_commit(::pg_query::OnCommitAction value) { _internal_set_on_commit(value); // @@protoc_insertion_point(field_set:pg_query.IntoClause.on_commit) } // string table_space_name = 6 [json_name = "tableSpaceName"]; inline void IntoClause::clear_table_space_name() { _impl_.table_space_name_.ClearToEmpty(); } inline const std::string& IntoClause::table_space_name() const { // @@protoc_insertion_point(field_get:pg_query.IntoClause.table_space_name) return _internal_table_space_name(); } template inline PROTOBUF_ALWAYS_INLINE void IntoClause::set_table_space_name(ArgT0&& arg0, ArgT... args) { _impl_.table_space_name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.IntoClause.table_space_name) } inline std::string* IntoClause::mutable_table_space_name() { 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 { return _impl_.table_space_name_.Get(); } inline void IntoClause::_internal_set_table_space_name(const std::string& value) { _impl_.table_space_name_.Set(value, GetArenaForAllocation()); } inline std::string* IntoClause::_internal_mutable_table_space_name() { return _impl_.table_space_name_.Mutable(GetArenaForAllocation()); } inline std::string* IntoClause::release_table_space_name() { // @@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* table_space_name) { if (table_space_name != nullptr) { } else { } _impl_.table_space_name_.SetAllocated(table_space_name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.table_space_name_.IsDefault()) { _impl_.table_space_name_.Set("", GetArenaForAllocation()); } #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::_internal_has_view_query() const { return this != internal_default_instance() && _impl_.view_query_ != nullptr; } inline bool IntoClause::has_view_query() const { return _internal_has_view_query(); } inline void IntoClause::clear_view_query() { if (GetArenaForAllocation() == nullptr && _impl_.view_query_ != nullptr) { delete _impl_.view_query_; } _impl_.view_query_ = nullptr; } inline const ::pg_query::Node& IntoClause::_internal_view_query() const { const ::pg_query::Node* p = _impl_.view_query_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& IntoClause::view_query() const { // @@protoc_insertion_point(field_get:pg_query.IntoClause.view_query) return _internal_view_query(); } inline void IntoClause::unsafe_arena_set_allocated_view_query( ::pg_query::Node* view_query) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.view_query_); } _impl_.view_query_ = view_query; if (view_query) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.IntoClause.view_query) } inline ::pg_query::Node* IntoClause::release_view_query() { ::pg_query::Node* temp = _impl_.view_query_; _impl_.view_query_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* IntoClause::unsafe_arena_release_view_query() { // @@protoc_insertion_point(field_release:pg_query.IntoClause.view_query) ::pg_query::Node* temp = _impl_.view_query_; _impl_.view_query_ = nullptr; return temp; } inline ::pg_query::Node* IntoClause::_internal_mutable_view_query() { if (_impl_.view_query_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.view_query_ = p; } return _impl_.view_query_; } inline ::pg_query::Node* IntoClause::mutable_view_query() { ::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* view_query) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.view_query_; } if (view_query) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(view_query); if (message_arena != submessage_arena) { view_query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, view_query, submessage_arena); } } else { } _impl_.view_query_ = view_query; // @@protoc_insertion_point(field_set_allocated:pg_query.IntoClause.view_query) } // bool skip_data = 8 [json_name = "skipData"]; inline void IntoClause::clear_skip_data() { _impl_.skip_data_ = false; } inline bool IntoClause::_internal_skip_data() const { return _impl_.skip_data_; } inline bool IntoClause::skip_data() const { // @@protoc_insertion_point(field_get:pg_query.IntoClause.skip_data) return _internal_skip_data(); } inline void IntoClause::_internal_set_skip_data(bool value) { _impl_.skip_data_ = value; } inline void IntoClause::set_skip_data(bool value) { _internal_set_skip_data(value); // @@protoc_insertion_point(field_set:pg_query.IntoClause.skip_data) } // ------------------------------------------------------------------- // MergeAction // bool matched = 1 [json_name = "matched"]; inline void MergeAction::clear_matched() { _impl_.matched_ = false; } inline bool MergeAction::_internal_matched() const { return _impl_.matched_; } inline bool MergeAction::matched() const { // @@protoc_insertion_point(field_get:pg_query.MergeAction.matched) return _internal_matched(); } inline void MergeAction::_internal_set_matched(bool value) { _impl_.matched_ = value; } inline void MergeAction::set_matched(bool value) { _internal_set_matched(value); // @@protoc_insertion_point(field_set:pg_query.MergeAction.matched) } // .pg_query.CmdType command_type = 2 [json_name = "commandType"]; inline void MergeAction::clear_command_type() { _impl_.command_type_ = 0; } inline ::pg_query::CmdType MergeAction::_internal_command_type() const { return static_cast< ::pg_query::CmdType >(_impl_.command_type_); } 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::_internal_set_command_type(::pg_query::CmdType value) { _impl_.command_type_ = value; } 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) } // .pg_query.OverridingKind override = 3 [json_name = "override"]; inline void MergeAction::clear_override() { _impl_.override_ = 0; } inline ::pg_query::OverridingKind MergeAction::_internal_override() const { return static_cast< ::pg_query::OverridingKind >(_impl_.override_); } inline ::pg_query::OverridingKind MergeAction::override() const { // @@protoc_insertion_point(field_get:pg_query.MergeAction.override) return _internal_override(); } inline void MergeAction::_internal_set_override(::pg_query::OverridingKind value) { _impl_.override_ = value; } inline void MergeAction::set_override(::pg_query::OverridingKind value) { _internal_set_override(value); // @@protoc_insertion_point(field_set:pg_query.MergeAction.override) } // .pg_query.Node qual = 4 [json_name = "qual"]; inline bool MergeAction::_internal_has_qual() const { return this != internal_default_instance() && _impl_.qual_ != nullptr; } inline bool MergeAction::has_qual() const { return _internal_has_qual(); } inline void MergeAction::clear_qual() { if (GetArenaForAllocation() == nullptr && _impl_.qual_ != nullptr) { delete _impl_.qual_; } _impl_.qual_ = nullptr; } inline const ::pg_query::Node& MergeAction::_internal_qual() const { const ::pg_query::Node* p = _impl_.qual_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& MergeAction::qual() const { // @@protoc_insertion_point(field_get:pg_query.MergeAction.qual) return _internal_qual(); } inline void MergeAction::unsafe_arena_set_allocated_qual( ::pg_query::Node* qual) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.qual_); } _impl_.qual_ = qual; if (qual) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.MergeAction.qual) } inline ::pg_query::Node* MergeAction::release_qual() { ::pg_query::Node* temp = _impl_.qual_; _impl_.qual_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* MergeAction::unsafe_arena_release_qual() { // @@protoc_insertion_point(field_release:pg_query.MergeAction.qual) ::pg_query::Node* temp = _impl_.qual_; _impl_.qual_ = nullptr; return temp; } inline ::pg_query::Node* MergeAction::_internal_mutable_qual() { if (_impl_.qual_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.qual_ = p; } return _impl_.qual_; } inline ::pg_query::Node* MergeAction::mutable_qual() { ::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* qual) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.qual_; } if (qual) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(qual); if (message_arena != submessage_arena) { qual = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, qual, submessage_arena); } } else { } _impl_.qual_ = qual; // @@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 _impl_.target_list_.size(); } inline int MergeAction::target_list_size() const { return _internal_target_list_size(); } inline void MergeAction::clear_target_list() { _impl_.target_list_.Clear(); } inline ::pg_query::Node* MergeAction::mutable_target_list(int index) { // @@protoc_insertion_point(field_mutable:pg_query.MergeAction.target_list) return _impl_.target_list_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* MergeAction::mutable_target_list() { // @@protoc_insertion_point(field_mutable_list:pg_query.MergeAction.target_list) return &_impl_.target_list_; } inline const ::pg_query::Node& MergeAction::_internal_target_list(int index) const { return _impl_.target_list_.Get(index); } inline const ::pg_query::Node& MergeAction::target_list(int index) const { // @@protoc_insertion_point(field_get:pg_query.MergeAction.target_list) return _internal_target_list(index); } inline ::pg_query::Node* MergeAction::_internal_add_target_list() { return _impl_.target_list_.Add(); } inline ::pg_query::Node* MergeAction::add_target_list() { ::pg_query::Node* _add = _internal_add_target_list(); // @@protoc_insertion_point(field_add:pg_query.MergeAction.target_list) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& MergeAction::target_list() const { // @@protoc_insertion_point(field_list:pg_query.MergeAction.target_list) return _impl_.target_list_; } // repeated .pg_query.Node update_colnos = 6 [json_name = "updateColnos"]; inline int MergeAction::_internal_update_colnos_size() const { return _impl_.update_colnos_.size(); } inline int MergeAction::update_colnos_size() const { return _internal_update_colnos_size(); } inline void MergeAction::clear_update_colnos() { _impl_.update_colnos_.Clear(); } inline ::pg_query::Node* MergeAction::mutable_update_colnos(int index) { // @@protoc_insertion_point(field_mutable:pg_query.MergeAction.update_colnos) return _impl_.update_colnos_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* MergeAction::mutable_update_colnos() { // @@protoc_insertion_point(field_mutable_list:pg_query.MergeAction.update_colnos) return &_impl_.update_colnos_; } inline const ::pg_query::Node& MergeAction::_internal_update_colnos(int index) const { return _impl_.update_colnos_.Get(index); } inline const ::pg_query::Node& MergeAction::update_colnos(int index) const { // @@protoc_insertion_point(field_get:pg_query.MergeAction.update_colnos) return _internal_update_colnos(index); } inline ::pg_query::Node* MergeAction::_internal_add_update_colnos() { return _impl_.update_colnos_.Add(); } inline ::pg_query::Node* MergeAction::add_update_colnos() { ::pg_query::Node* _add = _internal_add_update_colnos(); // @@protoc_insertion_point(field_add:pg_query.MergeAction.update_colnos) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& MergeAction::update_colnos() const { // @@protoc_insertion_point(field_list:pg_query.MergeAction.update_colnos) return _impl_.update_colnos_; } // ------------------------------------------------------------------- // RawStmt // .pg_query.Node stmt = 1 [json_name = "stmt"]; inline bool RawStmt::_internal_has_stmt() const { return this != internal_default_instance() && _impl_.stmt_ != nullptr; } inline bool RawStmt::has_stmt() const { return _internal_has_stmt(); } inline void RawStmt::clear_stmt() { if (GetArenaForAllocation() == nullptr && _impl_.stmt_ != nullptr) { delete _impl_.stmt_; } _impl_.stmt_ = nullptr; } inline const ::pg_query::Node& RawStmt::_internal_stmt() const { const ::pg_query::Node* p = _impl_.stmt_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& RawStmt::stmt() const { // @@protoc_insertion_point(field_get:pg_query.RawStmt.stmt) return _internal_stmt(); } inline void RawStmt::unsafe_arena_set_allocated_stmt( ::pg_query::Node* stmt) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.stmt_); } _impl_.stmt_ = stmt; if (stmt) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RawStmt.stmt) } inline ::pg_query::Node* RawStmt::release_stmt() { ::pg_query::Node* temp = _impl_.stmt_; _impl_.stmt_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* RawStmt::unsafe_arena_release_stmt() { // @@protoc_insertion_point(field_release:pg_query.RawStmt.stmt) ::pg_query::Node* temp = _impl_.stmt_; _impl_.stmt_ = nullptr; return temp; } inline ::pg_query::Node* RawStmt::_internal_mutable_stmt() { if (_impl_.stmt_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.stmt_ = p; } return _impl_.stmt_; } inline ::pg_query::Node* RawStmt::mutable_stmt() { ::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* stmt) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.stmt_; } if (stmt) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(stmt); if (message_arena != submessage_arena) { stmt = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, stmt, submessage_arena); } } else { } _impl_.stmt_ = stmt; // @@protoc_insertion_point(field_set_allocated:pg_query.RawStmt.stmt) } // int32 stmt_location = 2 [json_name = "stmt_location"]; inline void RawStmt::clear_stmt_location() { _impl_.stmt_location_ = 0; } inline int32_t RawStmt::_internal_stmt_location() const { return _impl_.stmt_location_; } inline int32_t RawStmt::stmt_location() const { // @@protoc_insertion_point(field_get:pg_query.RawStmt.stmt_location) return _internal_stmt_location(); } inline void RawStmt::_internal_set_stmt_location(int32_t value) { _impl_.stmt_location_ = value; } inline void RawStmt::set_stmt_location(int32_t value) { _internal_set_stmt_location(value); // @@protoc_insertion_point(field_set:pg_query.RawStmt.stmt_location) } // int32 stmt_len = 3 [json_name = "stmt_len"]; inline void RawStmt::clear_stmt_len() { _impl_.stmt_len_ = 0; } inline int32_t RawStmt::_internal_stmt_len() const { return _impl_.stmt_len_; } inline int32_t RawStmt::stmt_len() const { // @@protoc_insertion_point(field_get:pg_query.RawStmt.stmt_len) return _internal_stmt_len(); } inline void RawStmt::_internal_set_stmt_len(int32_t value) { _impl_.stmt_len_ = value; } inline void RawStmt::set_stmt_len(int32_t value) { _internal_set_stmt_len(value); // @@protoc_insertion_point(field_set:pg_query.RawStmt.stmt_len) } // ------------------------------------------------------------------- // Query // .pg_query.CmdType command_type = 1 [json_name = "commandType"]; inline void Query::clear_command_type() { _impl_.command_type_ = 0; } inline ::pg_query::CmdType Query::_internal_command_type() const { return static_cast< ::pg_query::CmdType >(_impl_.command_type_); } inline ::pg_query::CmdType Query::command_type() const { // @@protoc_insertion_point(field_get:pg_query.Query.command_type) return _internal_command_type(); } inline void Query::_internal_set_command_type(::pg_query::CmdType value) { _impl_.command_type_ = value; } inline void Query::set_command_type(::pg_query::CmdType value) { _internal_set_command_type(value); // @@protoc_insertion_point(field_set:pg_query.Query.command_type) } // .pg_query.QuerySource query_source = 2 [json_name = "querySource"]; inline void Query::clear_query_source() { _impl_.query_source_ = 0; } inline ::pg_query::QuerySource Query::_internal_query_source() const { return static_cast< ::pg_query::QuerySource >(_impl_.query_source_); } inline ::pg_query::QuerySource Query::query_source() const { // @@protoc_insertion_point(field_get:pg_query.Query.query_source) return _internal_query_source(); } inline void Query::_internal_set_query_source(::pg_query::QuerySource value) { _impl_.query_source_ = value; } inline void Query::set_query_source(::pg_query::QuerySource value) { _internal_set_query_source(value); // @@protoc_insertion_point(field_set:pg_query.Query.query_source) } // bool can_set_tag = 3 [json_name = "canSetTag"]; inline void Query::clear_can_set_tag() { _impl_.can_set_tag_ = false; } inline bool Query::_internal_can_set_tag() const { return _impl_.can_set_tag_; } inline bool Query::can_set_tag() const { // @@protoc_insertion_point(field_get:pg_query.Query.can_set_tag) return _internal_can_set_tag(); } inline void Query::_internal_set_can_set_tag(bool value) { _impl_.can_set_tag_ = value; } inline void Query::set_can_set_tag(bool value) { _internal_set_can_set_tag(value); // @@protoc_insertion_point(field_set:pg_query.Query.can_set_tag) } // .pg_query.Node utility_stmt = 4 [json_name = "utilityStmt"]; inline bool Query::_internal_has_utility_stmt() const { return this != internal_default_instance() && _impl_.utility_stmt_ != nullptr; } inline bool Query::has_utility_stmt() const { return _internal_has_utility_stmt(); } inline void Query::clear_utility_stmt() { if (GetArenaForAllocation() == nullptr && _impl_.utility_stmt_ != nullptr) { delete _impl_.utility_stmt_; } _impl_.utility_stmt_ = nullptr; } inline const ::pg_query::Node& Query::_internal_utility_stmt() const { const ::pg_query::Node* p = _impl_.utility_stmt_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& Query::utility_stmt() const { // @@protoc_insertion_point(field_get:pg_query.Query.utility_stmt) return _internal_utility_stmt(); } inline void Query::unsafe_arena_set_allocated_utility_stmt( ::pg_query::Node* utility_stmt) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.utility_stmt_); } _impl_.utility_stmt_ = utility_stmt; if (utility_stmt) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Query.utility_stmt) } inline ::pg_query::Node* Query::release_utility_stmt() { ::pg_query::Node* temp = _impl_.utility_stmt_; _impl_.utility_stmt_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* Query::unsafe_arena_release_utility_stmt() { // @@protoc_insertion_point(field_release:pg_query.Query.utility_stmt) ::pg_query::Node* temp = _impl_.utility_stmt_; _impl_.utility_stmt_ = nullptr; return temp; } inline ::pg_query::Node* Query::_internal_mutable_utility_stmt() { if (_impl_.utility_stmt_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.utility_stmt_ = p; } return _impl_.utility_stmt_; } inline ::pg_query::Node* Query::mutable_utility_stmt() { ::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* utility_stmt) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.utility_stmt_; } if (utility_stmt) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(utility_stmt); if (message_arena != submessage_arena) { utility_stmt = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, utility_stmt, submessage_arena); } } else { } _impl_.utility_stmt_ = utility_stmt; // @@protoc_insertion_point(field_set_allocated:pg_query.Query.utility_stmt) } // int32 result_relation = 5 [json_name = "resultRelation"]; inline void Query::clear_result_relation() { _impl_.result_relation_ = 0; } inline int32_t Query::_internal_result_relation() const { return _impl_.result_relation_; } inline int32_t Query::result_relation() const { // @@protoc_insertion_point(field_get:pg_query.Query.result_relation) return _internal_result_relation(); } inline void Query::_internal_set_result_relation(int32_t value) { _impl_.result_relation_ = value; } inline void Query::set_result_relation(int32_t value) { _internal_set_result_relation(value); // @@protoc_insertion_point(field_set:pg_query.Query.result_relation) } // bool has_aggs = 6 [json_name = "hasAggs"]; inline void Query::clear_has_aggs() { _impl_.has_aggs_ = false; } inline bool Query::_internal_has_aggs() const { return _impl_.has_aggs_; } inline bool Query::has_aggs() const { // @@protoc_insertion_point(field_get:pg_query.Query.has_aggs) return _internal_has_aggs(); } inline void Query::_internal_set_has_aggs(bool value) { _impl_.has_aggs_ = value; } inline void Query::set_has_aggs(bool value) { _internal_set_has_aggs(value); // @@protoc_insertion_point(field_set:pg_query.Query.has_aggs) } // bool has_window_funcs = 7 [json_name = "hasWindowFuncs"]; inline void Query::clear_has_window_funcs() { _impl_.has_window_funcs_ = false; } inline bool Query::_internal_has_window_funcs() const { return _impl_.has_window_funcs_; } inline bool Query::has_window_funcs() const { // @@protoc_insertion_point(field_get:pg_query.Query.has_window_funcs) return _internal_has_window_funcs(); } inline void Query::_internal_set_has_window_funcs(bool value) { _impl_.has_window_funcs_ = value; } inline void Query::set_has_window_funcs(bool value) { _internal_set_has_window_funcs(value); // @@protoc_insertion_point(field_set:pg_query.Query.has_window_funcs) } // bool has_target_srfs = 8 [json_name = "hasTargetSRFs"]; inline void Query::clear_has_target_srfs() { _impl_.has_target_srfs_ = false; } inline bool Query::_internal_has_target_srfs() const { return _impl_.has_target_srfs_; } inline bool Query::has_target_srfs() const { // @@protoc_insertion_point(field_get:pg_query.Query.has_target_srfs) return _internal_has_target_srfs(); } inline void Query::_internal_set_has_target_srfs(bool value) { _impl_.has_target_srfs_ = value; } inline void Query::set_has_target_srfs(bool value) { _internal_set_has_target_srfs(value); // @@protoc_insertion_point(field_set:pg_query.Query.has_target_srfs) } // bool has_sub_links = 9 [json_name = "hasSubLinks"]; inline void Query::clear_has_sub_links() { _impl_.has_sub_links_ = false; } inline bool Query::_internal_has_sub_links() const { return _impl_.has_sub_links_; } inline bool Query::has_sub_links() const { // @@protoc_insertion_point(field_get:pg_query.Query.has_sub_links) return _internal_has_sub_links(); } inline void Query::_internal_set_has_sub_links(bool value) { _impl_.has_sub_links_ = value; } inline void Query::set_has_sub_links(bool value) { _internal_set_has_sub_links(value); // @@protoc_insertion_point(field_set:pg_query.Query.has_sub_links) } // bool has_distinct_on = 10 [json_name = "hasDistinctOn"]; inline void Query::clear_has_distinct_on() { _impl_.has_distinct_on_ = false; } inline bool Query::_internal_has_distinct_on() const { return _impl_.has_distinct_on_; } inline bool Query::has_distinct_on() const { // @@protoc_insertion_point(field_get:pg_query.Query.has_distinct_on) return _internal_has_distinct_on(); } inline void Query::_internal_set_has_distinct_on(bool value) { _impl_.has_distinct_on_ = value; } inline void Query::set_has_distinct_on(bool value) { _internal_set_has_distinct_on(value); // @@protoc_insertion_point(field_set:pg_query.Query.has_distinct_on) } // bool has_recursive = 11 [json_name = "hasRecursive"]; inline void Query::clear_has_recursive() { _impl_.has_recursive_ = false; } inline bool Query::_internal_has_recursive() const { return _impl_.has_recursive_; } inline bool Query::has_recursive() const { // @@protoc_insertion_point(field_get:pg_query.Query.has_recursive) return _internal_has_recursive(); } inline void Query::_internal_set_has_recursive(bool value) { _impl_.has_recursive_ = value; } inline void Query::set_has_recursive(bool value) { _internal_set_has_recursive(value); // @@protoc_insertion_point(field_set:pg_query.Query.has_recursive) } // bool has_modifying_cte = 12 [json_name = "hasModifyingCTE"]; inline void Query::clear_has_modifying_cte() { _impl_.has_modifying_cte_ = false; } inline bool Query::_internal_has_modifying_cte() const { return _impl_.has_modifying_cte_; } inline bool Query::has_modifying_cte() const { // @@protoc_insertion_point(field_get:pg_query.Query.has_modifying_cte) return _internal_has_modifying_cte(); } inline void Query::_internal_set_has_modifying_cte(bool value) { _impl_.has_modifying_cte_ = value; } inline void Query::set_has_modifying_cte(bool value) { _internal_set_has_modifying_cte(value); // @@protoc_insertion_point(field_set:pg_query.Query.has_modifying_cte) } // bool has_for_update = 13 [json_name = "hasForUpdate"]; inline void Query::clear_has_for_update() { _impl_.has_for_update_ = false; } inline bool Query::_internal_has_for_update() const { return _impl_.has_for_update_; } inline bool Query::has_for_update() const { // @@protoc_insertion_point(field_get:pg_query.Query.has_for_update) return _internal_has_for_update(); } inline void Query::_internal_set_has_for_update(bool value) { _impl_.has_for_update_ = value; } inline void Query::set_has_for_update(bool value) { _internal_set_has_for_update(value); // @@protoc_insertion_point(field_set:pg_query.Query.has_for_update) } // bool has_row_security = 14 [json_name = "hasRowSecurity"]; inline void Query::clear_has_row_security() { _impl_.has_row_security_ = false; } inline bool Query::_internal_has_row_security() const { return _impl_.has_row_security_; } inline bool Query::has_row_security() const { // @@protoc_insertion_point(field_get:pg_query.Query.has_row_security) return _internal_has_row_security(); } inline void Query::_internal_set_has_row_security(bool value) { _impl_.has_row_security_ = value; } inline void Query::set_has_row_security(bool value) { _internal_set_has_row_security(value); // @@protoc_insertion_point(field_set:pg_query.Query.has_row_security) } // bool is_return = 15 [json_name = "isReturn"]; inline void Query::clear_is_return() { _impl_.is_return_ = false; } inline bool Query::_internal_is_return() const { return _impl_.is_return_; } inline bool Query::is_return() const { // @@protoc_insertion_point(field_get:pg_query.Query.is_return) return _internal_is_return(); } inline void Query::_internal_set_is_return(bool value) { _impl_.is_return_ = value; } inline void Query::set_is_return(bool value) { _internal_set_is_return(value); // @@protoc_insertion_point(field_set:pg_query.Query.is_return) } // repeated .pg_query.Node cte_list = 16 [json_name = "cteList"]; inline int Query::_internal_cte_list_size() const { return _impl_.cte_list_.size(); } inline int Query::cte_list_size() const { return _internal_cte_list_size(); } inline void Query::clear_cte_list() { _impl_.cte_list_.Clear(); } inline ::pg_query::Node* Query::mutable_cte_list(int index) { // @@protoc_insertion_point(field_mutable:pg_query.Query.cte_list) return _impl_.cte_list_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* Query::mutable_cte_list() { // @@protoc_insertion_point(field_mutable_list:pg_query.Query.cte_list) return &_impl_.cte_list_; } inline const ::pg_query::Node& Query::_internal_cte_list(int index) const { return _impl_.cte_list_.Get(index); } inline const ::pg_query::Node& Query::cte_list(int index) const { // @@protoc_insertion_point(field_get:pg_query.Query.cte_list) return _internal_cte_list(index); } inline ::pg_query::Node* Query::_internal_add_cte_list() { return _impl_.cte_list_.Add(); } inline ::pg_query::Node* Query::add_cte_list() { ::pg_query::Node* _add = _internal_add_cte_list(); // @@protoc_insertion_point(field_add:pg_query.Query.cte_list) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& Query::cte_list() const { // @@protoc_insertion_point(field_list:pg_query.Query.cte_list) return _impl_.cte_list_; } // repeated .pg_query.Node rtable = 17 [json_name = "rtable"]; inline int Query::_internal_rtable_size() const { return _impl_.rtable_.size(); } inline int Query::rtable_size() const { return _internal_rtable_size(); } inline void Query::clear_rtable() { _impl_.rtable_.Clear(); } inline ::pg_query::Node* Query::mutable_rtable(int index) { // @@protoc_insertion_point(field_mutable:pg_query.Query.rtable) return _impl_.rtable_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* Query::mutable_rtable() { // @@protoc_insertion_point(field_mutable_list:pg_query.Query.rtable) return &_impl_.rtable_; } inline const ::pg_query::Node& Query::_internal_rtable(int index) const { return _impl_.rtable_.Get(index); } inline const ::pg_query::Node& Query::rtable(int index) const { // @@protoc_insertion_point(field_get:pg_query.Query.rtable) return _internal_rtable(index); } inline ::pg_query::Node* Query::_internal_add_rtable() { return _impl_.rtable_.Add(); } inline ::pg_query::Node* Query::add_rtable() { ::pg_query::Node* _add = _internal_add_rtable(); // @@protoc_insertion_point(field_add:pg_query.Query.rtable) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& Query::rtable() const { // @@protoc_insertion_point(field_list:pg_query.Query.rtable) return _impl_.rtable_; } // .pg_query.FromExpr jointree = 18 [json_name = "jointree"]; inline bool Query::_internal_has_jointree() const { return this != internal_default_instance() && _impl_.jointree_ != nullptr; } inline bool Query::has_jointree() const { return _internal_has_jointree(); } inline void Query::clear_jointree() { if (GetArenaForAllocation() == nullptr && _impl_.jointree_ != nullptr) { delete _impl_.jointree_; } _impl_.jointree_ = nullptr; } inline const ::pg_query::FromExpr& Query::_internal_jointree() const { const ::pg_query::FromExpr* p = _impl_.jointree_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_FromExpr_default_instance_); } inline const ::pg_query::FromExpr& Query::jointree() const { // @@protoc_insertion_point(field_get:pg_query.Query.jointree) return _internal_jointree(); } inline void Query::unsafe_arena_set_allocated_jointree( ::pg_query::FromExpr* jointree) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.jointree_); } _impl_.jointree_ = jointree; if (jointree) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Query.jointree) } inline ::pg_query::FromExpr* Query::release_jointree() { ::pg_query::FromExpr* temp = _impl_.jointree_; _impl_.jointree_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::FromExpr* Query::unsafe_arena_release_jointree() { // @@protoc_insertion_point(field_release:pg_query.Query.jointree) ::pg_query::FromExpr* temp = _impl_.jointree_; _impl_.jointree_ = nullptr; return temp; } inline ::pg_query::FromExpr* Query::_internal_mutable_jointree() { if (_impl_.jointree_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::FromExpr>(GetArenaForAllocation()); _impl_.jointree_ = p; } return _impl_.jointree_; } inline ::pg_query::FromExpr* Query::mutable_jointree() { ::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* jointree) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.jointree_; } if (jointree) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(jointree); if (message_arena != submessage_arena) { jointree = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, jointree, submessage_arena); } } else { } _impl_.jointree_ = jointree; // @@protoc_insertion_point(field_set_allocated:pg_query.Query.jointree) } // repeated .pg_query.Node merge_action_list = 19 [json_name = "mergeActionList"]; inline int Query::_internal_merge_action_list_size() const { return _impl_.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() { _impl_.merge_action_list_.Clear(); } inline ::pg_query::Node* Query::mutable_merge_action_list(int index) { // @@protoc_insertion_point(field_mutable:pg_query.Query.merge_action_list) return _impl_.merge_action_list_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* Query::mutable_merge_action_list() { // @@protoc_insertion_point(field_mutable_list:pg_query.Query.merge_action_list) return &_impl_.merge_action_list_; } inline const ::pg_query::Node& Query::_internal_merge_action_list(int index) const { return _impl_.merge_action_list_.Get(index); } inline const ::pg_query::Node& Query::merge_action_list(int index) const { // @@protoc_insertion_point(field_get:pg_query.Query.merge_action_list) return _internal_merge_action_list(index); } inline ::pg_query::Node* Query::_internal_add_merge_action_list() { return _impl_.merge_action_list_.Add(); } inline ::pg_query::Node* Query::add_merge_action_list() { ::pg_query::Node* _add = _internal_add_merge_action_list(); // @@protoc_insertion_point(field_add:pg_query.Query.merge_action_list) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& Query::merge_action_list() const { // @@protoc_insertion_point(field_list:pg_query.Query.merge_action_list) return _impl_.merge_action_list_; } // bool merge_use_outer_join = 20 [json_name = "mergeUseOuterJoin"]; inline void Query::clear_merge_use_outer_join() { _impl_.merge_use_outer_join_ = false; } inline bool Query::_internal_merge_use_outer_join() const { return _impl_.merge_use_outer_join_; } 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::_internal_set_merge_use_outer_join(bool value) { _impl_.merge_use_outer_join_ = value; } 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) } // repeated .pg_query.Node target_list = 21 [json_name = "targetList"]; inline int Query::_internal_target_list_size() const { return _impl_.target_list_.size(); } inline int Query::target_list_size() const { return _internal_target_list_size(); } inline void Query::clear_target_list() { _impl_.target_list_.Clear(); } inline ::pg_query::Node* Query::mutable_target_list(int index) { // @@protoc_insertion_point(field_mutable:pg_query.Query.target_list) return _impl_.target_list_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* Query::mutable_target_list() { // @@protoc_insertion_point(field_mutable_list:pg_query.Query.target_list) return &_impl_.target_list_; } inline const ::pg_query::Node& Query::_internal_target_list(int index) const { return _impl_.target_list_.Get(index); } inline const ::pg_query::Node& Query::target_list(int index) const { // @@protoc_insertion_point(field_get:pg_query.Query.target_list) return _internal_target_list(index); } inline ::pg_query::Node* Query::_internal_add_target_list() { return _impl_.target_list_.Add(); } inline ::pg_query::Node* Query::add_target_list() { ::pg_query::Node* _add = _internal_add_target_list(); // @@protoc_insertion_point(field_add:pg_query.Query.target_list) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& Query::target_list() const { // @@protoc_insertion_point(field_list:pg_query.Query.target_list) return _impl_.target_list_; } // .pg_query.OverridingKind override = 22 [json_name = "override"]; inline void Query::clear_override() { _impl_.override_ = 0; } inline ::pg_query::OverridingKind Query::_internal_override() const { return static_cast< ::pg_query::OverridingKind >(_impl_.override_); } inline ::pg_query::OverridingKind Query::override() const { // @@protoc_insertion_point(field_get:pg_query.Query.override) return _internal_override(); } inline void Query::_internal_set_override(::pg_query::OverridingKind value) { _impl_.override_ = value; } inline void Query::set_override(::pg_query::OverridingKind value) { _internal_set_override(value); // @@protoc_insertion_point(field_set:pg_query.Query.override) } // .pg_query.OnConflictExpr on_conflict = 23 [json_name = "onConflict"]; inline bool Query::_internal_has_on_conflict() const { return this != internal_default_instance() && _impl_.on_conflict_ != nullptr; } inline bool Query::has_on_conflict() const { return _internal_has_on_conflict(); } inline void Query::clear_on_conflict() { if (GetArenaForAllocation() == nullptr && _impl_.on_conflict_ != nullptr) { delete _impl_.on_conflict_; } _impl_.on_conflict_ = nullptr; } inline const ::pg_query::OnConflictExpr& Query::_internal_on_conflict() const { const ::pg_query::OnConflictExpr* p = _impl_.on_conflict_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_OnConflictExpr_default_instance_); } inline const ::pg_query::OnConflictExpr& Query::on_conflict() const { // @@protoc_insertion_point(field_get:pg_query.Query.on_conflict) return _internal_on_conflict(); } inline void Query::unsafe_arena_set_allocated_on_conflict( ::pg_query::OnConflictExpr* on_conflict) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.on_conflict_); } _impl_.on_conflict_ = on_conflict; if (on_conflict) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Query.on_conflict) } inline ::pg_query::OnConflictExpr* Query::release_on_conflict() { ::pg_query::OnConflictExpr* temp = _impl_.on_conflict_; _impl_.on_conflict_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::OnConflictExpr* Query::unsafe_arena_release_on_conflict() { // @@protoc_insertion_point(field_release:pg_query.Query.on_conflict) ::pg_query::OnConflictExpr* temp = _impl_.on_conflict_; _impl_.on_conflict_ = nullptr; return temp; } inline ::pg_query::OnConflictExpr* Query::_internal_mutable_on_conflict() { if (_impl_.on_conflict_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::OnConflictExpr>(GetArenaForAllocation()); _impl_.on_conflict_ = p; } return _impl_.on_conflict_; } inline ::pg_query::OnConflictExpr* Query::mutable_on_conflict() { ::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* on_conflict) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.on_conflict_; } if (on_conflict) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(on_conflict); if (message_arena != submessage_arena) { on_conflict = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, on_conflict, submessage_arena); } } else { } _impl_.on_conflict_ = on_conflict; // @@protoc_insertion_point(field_set_allocated:pg_query.Query.on_conflict) } // repeated .pg_query.Node returning_list = 24 [json_name = "returningList"]; inline int Query::_internal_returning_list_size() const { return _impl_.returning_list_.size(); } inline int Query::returning_list_size() const { return _internal_returning_list_size(); } inline void Query::clear_returning_list() { _impl_.returning_list_.Clear(); } inline ::pg_query::Node* Query::mutable_returning_list(int index) { // @@protoc_insertion_point(field_mutable:pg_query.Query.returning_list) return _impl_.returning_list_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* Query::mutable_returning_list() { // @@protoc_insertion_point(field_mutable_list:pg_query.Query.returning_list) return &_impl_.returning_list_; } inline const ::pg_query::Node& Query::_internal_returning_list(int index) const { return _impl_.returning_list_.Get(index); } inline const ::pg_query::Node& Query::returning_list(int index) const { // @@protoc_insertion_point(field_get:pg_query.Query.returning_list) return _internal_returning_list(index); } inline ::pg_query::Node* Query::_internal_add_returning_list() { return _impl_.returning_list_.Add(); } inline ::pg_query::Node* Query::add_returning_list() { ::pg_query::Node* _add = _internal_add_returning_list(); // @@protoc_insertion_point(field_add:pg_query.Query.returning_list) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& Query::returning_list() const { // @@protoc_insertion_point(field_list:pg_query.Query.returning_list) return _impl_.returning_list_; } // repeated .pg_query.Node group_clause = 25 [json_name = "groupClause"]; inline int Query::_internal_group_clause_size() const { return _impl_.group_clause_.size(); } inline int Query::group_clause_size() const { return _internal_group_clause_size(); } inline void Query::clear_group_clause() { _impl_.group_clause_.Clear(); } inline ::pg_query::Node* Query::mutable_group_clause(int index) { // @@protoc_insertion_point(field_mutable:pg_query.Query.group_clause) return _impl_.group_clause_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* Query::mutable_group_clause() { // @@protoc_insertion_point(field_mutable_list:pg_query.Query.group_clause) return &_impl_.group_clause_; } inline const ::pg_query::Node& Query::_internal_group_clause(int index) const { return _impl_.group_clause_.Get(index); } inline const ::pg_query::Node& Query::group_clause(int index) const { // @@protoc_insertion_point(field_get:pg_query.Query.group_clause) return _internal_group_clause(index); } inline ::pg_query::Node* Query::_internal_add_group_clause() { return _impl_.group_clause_.Add(); } inline ::pg_query::Node* Query::add_group_clause() { ::pg_query::Node* _add = _internal_add_group_clause(); // @@protoc_insertion_point(field_add:pg_query.Query.group_clause) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& Query::group_clause() const { // @@protoc_insertion_point(field_list:pg_query.Query.group_clause) return _impl_.group_clause_; } // bool group_distinct = 26 [json_name = "groupDistinct"]; inline void Query::clear_group_distinct() { _impl_.group_distinct_ = false; } inline bool Query::_internal_group_distinct() const { return _impl_.group_distinct_; } inline bool Query::group_distinct() const { // @@protoc_insertion_point(field_get:pg_query.Query.group_distinct) return _internal_group_distinct(); } inline void Query::_internal_set_group_distinct(bool value) { _impl_.group_distinct_ = value; } inline void Query::set_group_distinct(bool value) { _internal_set_group_distinct(value); // @@protoc_insertion_point(field_set:pg_query.Query.group_distinct) } // repeated .pg_query.Node grouping_sets = 27 [json_name = "groupingSets"]; inline int Query::_internal_grouping_sets_size() const { return _impl_.grouping_sets_.size(); } inline int Query::grouping_sets_size() const { return _internal_grouping_sets_size(); } inline void Query::clear_grouping_sets() { _impl_.grouping_sets_.Clear(); } inline ::pg_query::Node* Query::mutable_grouping_sets(int index) { // @@protoc_insertion_point(field_mutable:pg_query.Query.grouping_sets) return _impl_.grouping_sets_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* Query::mutable_grouping_sets() { // @@protoc_insertion_point(field_mutable_list:pg_query.Query.grouping_sets) return &_impl_.grouping_sets_; } inline const ::pg_query::Node& Query::_internal_grouping_sets(int index) const { return _impl_.grouping_sets_.Get(index); } inline const ::pg_query::Node& Query::grouping_sets(int index) const { // @@protoc_insertion_point(field_get:pg_query.Query.grouping_sets) return _internal_grouping_sets(index); } inline ::pg_query::Node* Query::_internal_add_grouping_sets() { return _impl_.grouping_sets_.Add(); } inline ::pg_query::Node* Query::add_grouping_sets() { ::pg_query::Node* _add = _internal_add_grouping_sets(); // @@protoc_insertion_point(field_add:pg_query.Query.grouping_sets) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& Query::grouping_sets() const { // @@protoc_insertion_point(field_list:pg_query.Query.grouping_sets) return _impl_.grouping_sets_; } // .pg_query.Node having_qual = 28 [json_name = "havingQual"]; inline bool Query::_internal_has_having_qual() const { return this != internal_default_instance() && _impl_.having_qual_ != nullptr; } inline bool Query::has_having_qual() const { return _internal_has_having_qual(); } inline void Query::clear_having_qual() { if (GetArenaForAllocation() == nullptr && _impl_.having_qual_ != nullptr) { delete _impl_.having_qual_; } _impl_.having_qual_ = nullptr; } inline const ::pg_query::Node& Query::_internal_having_qual() const { const ::pg_query::Node* p = _impl_.having_qual_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& Query::having_qual() const { // @@protoc_insertion_point(field_get:pg_query.Query.having_qual) return _internal_having_qual(); } inline void Query::unsafe_arena_set_allocated_having_qual( ::pg_query::Node* having_qual) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.having_qual_); } _impl_.having_qual_ = having_qual; if (having_qual) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Query.having_qual) } inline ::pg_query::Node* Query::release_having_qual() { ::pg_query::Node* temp = _impl_.having_qual_; _impl_.having_qual_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* Query::unsafe_arena_release_having_qual() { // @@protoc_insertion_point(field_release:pg_query.Query.having_qual) ::pg_query::Node* temp = _impl_.having_qual_; _impl_.having_qual_ = nullptr; return temp; } inline ::pg_query::Node* Query::_internal_mutable_having_qual() { if (_impl_.having_qual_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.having_qual_ = p; } return _impl_.having_qual_; } inline ::pg_query::Node* Query::mutable_having_qual() { ::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* having_qual) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.having_qual_; } if (having_qual) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(having_qual); if (message_arena != submessage_arena) { having_qual = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, having_qual, submessage_arena); } } else { } _impl_.having_qual_ = having_qual; // @@protoc_insertion_point(field_set_allocated:pg_query.Query.having_qual) } // repeated .pg_query.Node window_clause = 29 [json_name = "windowClause"]; inline int Query::_internal_window_clause_size() const { return _impl_.window_clause_.size(); } inline int Query::window_clause_size() const { return _internal_window_clause_size(); } inline void Query::clear_window_clause() { _impl_.window_clause_.Clear(); } inline ::pg_query::Node* Query::mutable_window_clause(int index) { // @@protoc_insertion_point(field_mutable:pg_query.Query.window_clause) return _impl_.window_clause_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* Query::mutable_window_clause() { // @@protoc_insertion_point(field_mutable_list:pg_query.Query.window_clause) return &_impl_.window_clause_; } inline const ::pg_query::Node& Query::_internal_window_clause(int index) const { return _impl_.window_clause_.Get(index); } inline const ::pg_query::Node& Query::window_clause(int index) const { // @@protoc_insertion_point(field_get:pg_query.Query.window_clause) return _internal_window_clause(index); } inline ::pg_query::Node* Query::_internal_add_window_clause() { return _impl_.window_clause_.Add(); } inline ::pg_query::Node* Query::add_window_clause() { ::pg_query::Node* _add = _internal_add_window_clause(); // @@protoc_insertion_point(field_add:pg_query.Query.window_clause) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& Query::window_clause() const { // @@protoc_insertion_point(field_list:pg_query.Query.window_clause) return _impl_.window_clause_; } // repeated .pg_query.Node distinct_clause = 30 [json_name = "distinctClause"]; inline int Query::_internal_distinct_clause_size() const { return _impl_.distinct_clause_.size(); } inline int Query::distinct_clause_size() const { return _internal_distinct_clause_size(); } inline void Query::clear_distinct_clause() { _impl_.distinct_clause_.Clear(); } inline ::pg_query::Node* Query::mutable_distinct_clause(int index) { // @@protoc_insertion_point(field_mutable:pg_query.Query.distinct_clause) return _impl_.distinct_clause_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* Query::mutable_distinct_clause() { // @@protoc_insertion_point(field_mutable_list:pg_query.Query.distinct_clause) return &_impl_.distinct_clause_; } inline const ::pg_query::Node& Query::_internal_distinct_clause(int index) const { return _impl_.distinct_clause_.Get(index); } inline const ::pg_query::Node& Query::distinct_clause(int index) const { // @@protoc_insertion_point(field_get:pg_query.Query.distinct_clause) return _internal_distinct_clause(index); } inline ::pg_query::Node* Query::_internal_add_distinct_clause() { return _impl_.distinct_clause_.Add(); } inline ::pg_query::Node* Query::add_distinct_clause() { ::pg_query::Node* _add = _internal_add_distinct_clause(); // @@protoc_insertion_point(field_add:pg_query.Query.distinct_clause) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& Query::distinct_clause() const { // @@protoc_insertion_point(field_list:pg_query.Query.distinct_clause) return _impl_.distinct_clause_; } // repeated .pg_query.Node sort_clause = 31 [json_name = "sortClause"]; inline int Query::_internal_sort_clause_size() const { return _impl_.sort_clause_.size(); } inline int Query::sort_clause_size() const { return _internal_sort_clause_size(); } inline void Query::clear_sort_clause() { _impl_.sort_clause_.Clear(); } inline ::pg_query::Node* Query::mutable_sort_clause(int index) { // @@protoc_insertion_point(field_mutable:pg_query.Query.sort_clause) return _impl_.sort_clause_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* Query::mutable_sort_clause() { // @@protoc_insertion_point(field_mutable_list:pg_query.Query.sort_clause) return &_impl_.sort_clause_; } inline const ::pg_query::Node& Query::_internal_sort_clause(int index) const { return _impl_.sort_clause_.Get(index); } inline const ::pg_query::Node& Query::sort_clause(int index) const { // @@protoc_insertion_point(field_get:pg_query.Query.sort_clause) return _internal_sort_clause(index); } inline ::pg_query::Node* Query::_internal_add_sort_clause() { return _impl_.sort_clause_.Add(); } inline ::pg_query::Node* Query::add_sort_clause() { ::pg_query::Node* _add = _internal_add_sort_clause(); // @@protoc_insertion_point(field_add:pg_query.Query.sort_clause) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& Query::sort_clause() const { // @@protoc_insertion_point(field_list:pg_query.Query.sort_clause) return _impl_.sort_clause_; } // .pg_query.Node limit_offset = 32 [json_name = "limitOffset"]; inline bool Query::_internal_has_limit_offset() const { return this != internal_default_instance() && _impl_.limit_offset_ != nullptr; } inline bool Query::has_limit_offset() const { return _internal_has_limit_offset(); } inline void Query::clear_limit_offset() { if (GetArenaForAllocation() == nullptr && _impl_.limit_offset_ != nullptr) { delete _impl_.limit_offset_; } _impl_.limit_offset_ = nullptr; } inline const ::pg_query::Node& Query::_internal_limit_offset() const { const ::pg_query::Node* p = _impl_.limit_offset_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& Query::limit_offset() const { // @@protoc_insertion_point(field_get:pg_query.Query.limit_offset) return _internal_limit_offset(); } inline void Query::unsafe_arena_set_allocated_limit_offset( ::pg_query::Node* limit_offset) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.limit_offset_); } _impl_.limit_offset_ = limit_offset; if (limit_offset) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Query.limit_offset) } inline ::pg_query::Node* Query::release_limit_offset() { ::pg_query::Node* temp = _impl_.limit_offset_; _impl_.limit_offset_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* Query::unsafe_arena_release_limit_offset() { // @@protoc_insertion_point(field_release:pg_query.Query.limit_offset) ::pg_query::Node* temp = _impl_.limit_offset_; _impl_.limit_offset_ = nullptr; return temp; } inline ::pg_query::Node* Query::_internal_mutable_limit_offset() { if (_impl_.limit_offset_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.limit_offset_ = p; } return _impl_.limit_offset_; } inline ::pg_query::Node* Query::mutable_limit_offset() { ::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* limit_offset) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.limit_offset_; } if (limit_offset) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(limit_offset); if (message_arena != submessage_arena) { limit_offset = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, limit_offset, submessage_arena); } } else { } _impl_.limit_offset_ = limit_offset; // @@protoc_insertion_point(field_set_allocated:pg_query.Query.limit_offset) } // .pg_query.Node limit_count = 33 [json_name = "limitCount"]; inline bool Query::_internal_has_limit_count() const { return this != internal_default_instance() && _impl_.limit_count_ != nullptr; } inline bool Query::has_limit_count() const { return _internal_has_limit_count(); } inline void Query::clear_limit_count() { if (GetArenaForAllocation() == nullptr && _impl_.limit_count_ != nullptr) { delete _impl_.limit_count_; } _impl_.limit_count_ = nullptr; } inline const ::pg_query::Node& Query::_internal_limit_count() const { const ::pg_query::Node* p = _impl_.limit_count_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& Query::limit_count() const { // @@protoc_insertion_point(field_get:pg_query.Query.limit_count) return _internal_limit_count(); } inline void Query::unsafe_arena_set_allocated_limit_count( ::pg_query::Node* limit_count) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.limit_count_); } _impl_.limit_count_ = limit_count; if (limit_count) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Query.limit_count) } inline ::pg_query::Node* Query::release_limit_count() { ::pg_query::Node* temp = _impl_.limit_count_; _impl_.limit_count_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* Query::unsafe_arena_release_limit_count() { // @@protoc_insertion_point(field_release:pg_query.Query.limit_count) ::pg_query::Node* temp = _impl_.limit_count_; _impl_.limit_count_ = nullptr; return temp; } inline ::pg_query::Node* Query::_internal_mutable_limit_count() { if (_impl_.limit_count_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.limit_count_ = p; } return _impl_.limit_count_; } inline ::pg_query::Node* Query::mutable_limit_count() { ::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* limit_count) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.limit_count_; } if (limit_count) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(limit_count); if (message_arena != submessage_arena) { limit_count = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, limit_count, submessage_arena); } } else { } _impl_.limit_count_ = limit_count; // @@protoc_insertion_point(field_set_allocated:pg_query.Query.limit_count) } // .pg_query.LimitOption limit_option = 34 [json_name = "limitOption"]; inline void Query::clear_limit_option() { _impl_.limit_option_ = 0; } inline ::pg_query::LimitOption Query::_internal_limit_option() const { return static_cast< ::pg_query::LimitOption >(_impl_.limit_option_); } inline ::pg_query::LimitOption Query::limit_option() const { // @@protoc_insertion_point(field_get:pg_query.Query.limit_option) return _internal_limit_option(); } inline void Query::_internal_set_limit_option(::pg_query::LimitOption value) { _impl_.limit_option_ = value; } inline void Query::set_limit_option(::pg_query::LimitOption value) { _internal_set_limit_option(value); // @@protoc_insertion_point(field_set:pg_query.Query.limit_option) } // repeated .pg_query.Node row_marks = 35 [json_name = "rowMarks"]; inline int Query::_internal_row_marks_size() const { return _impl_.row_marks_.size(); } inline int Query::row_marks_size() const { return _internal_row_marks_size(); } inline void Query::clear_row_marks() { _impl_.row_marks_.Clear(); } inline ::pg_query::Node* Query::mutable_row_marks(int index) { // @@protoc_insertion_point(field_mutable:pg_query.Query.row_marks) return _impl_.row_marks_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* Query::mutable_row_marks() { // @@protoc_insertion_point(field_mutable_list:pg_query.Query.row_marks) return &_impl_.row_marks_; } inline const ::pg_query::Node& Query::_internal_row_marks(int index) const { return _impl_.row_marks_.Get(index); } inline const ::pg_query::Node& Query::row_marks(int index) const { // @@protoc_insertion_point(field_get:pg_query.Query.row_marks) return _internal_row_marks(index); } inline ::pg_query::Node* Query::_internal_add_row_marks() { return _impl_.row_marks_.Add(); } inline ::pg_query::Node* Query::add_row_marks() { ::pg_query::Node* _add = _internal_add_row_marks(); // @@protoc_insertion_point(field_add:pg_query.Query.row_marks) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& Query::row_marks() const { // @@protoc_insertion_point(field_list:pg_query.Query.row_marks) return _impl_.row_marks_; } // .pg_query.Node set_operations = 36 [json_name = "setOperations"]; inline bool Query::_internal_has_set_operations() const { return this != internal_default_instance() && _impl_.set_operations_ != nullptr; } inline bool Query::has_set_operations() const { return _internal_has_set_operations(); } inline void Query::clear_set_operations() { if (GetArenaForAllocation() == nullptr && _impl_.set_operations_ != nullptr) { delete _impl_.set_operations_; } _impl_.set_operations_ = nullptr; } inline const ::pg_query::Node& Query::_internal_set_operations() const { const ::pg_query::Node* p = _impl_.set_operations_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& Query::set_operations() const { // @@protoc_insertion_point(field_get:pg_query.Query.set_operations) return _internal_set_operations(); } inline void Query::unsafe_arena_set_allocated_set_operations( ::pg_query::Node* set_operations) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.set_operations_); } _impl_.set_operations_ = set_operations; if (set_operations) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Query.set_operations) } inline ::pg_query::Node* Query::release_set_operations() { ::pg_query::Node* temp = _impl_.set_operations_; _impl_.set_operations_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* Query::unsafe_arena_release_set_operations() { // @@protoc_insertion_point(field_release:pg_query.Query.set_operations) ::pg_query::Node* temp = _impl_.set_operations_; _impl_.set_operations_ = nullptr; return temp; } inline ::pg_query::Node* Query::_internal_mutable_set_operations() { if (_impl_.set_operations_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.set_operations_ = p; } return _impl_.set_operations_; } inline ::pg_query::Node* Query::mutable_set_operations() { ::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* set_operations) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.set_operations_; } if (set_operations) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(set_operations); if (message_arena != submessage_arena) { set_operations = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, set_operations, submessage_arena); } } else { } _impl_.set_operations_ = set_operations; // @@protoc_insertion_point(field_set_allocated:pg_query.Query.set_operations) } // repeated .pg_query.Node constraint_deps = 37 [json_name = "constraintDeps"]; inline int Query::_internal_constraint_deps_size() const { return _impl_.constraint_deps_.size(); } inline int Query::constraint_deps_size() const { return _internal_constraint_deps_size(); } inline void Query::clear_constraint_deps() { _impl_.constraint_deps_.Clear(); } inline ::pg_query::Node* Query::mutable_constraint_deps(int index) { // @@protoc_insertion_point(field_mutable:pg_query.Query.constraint_deps) return _impl_.constraint_deps_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* Query::mutable_constraint_deps() { // @@protoc_insertion_point(field_mutable_list:pg_query.Query.constraint_deps) return &_impl_.constraint_deps_; } inline const ::pg_query::Node& Query::_internal_constraint_deps(int index) const { return _impl_.constraint_deps_.Get(index); } inline const ::pg_query::Node& Query::constraint_deps(int index) const { // @@protoc_insertion_point(field_get:pg_query.Query.constraint_deps) return _internal_constraint_deps(index); } inline ::pg_query::Node* Query::_internal_add_constraint_deps() { return _impl_.constraint_deps_.Add(); } inline ::pg_query::Node* Query::add_constraint_deps() { ::pg_query::Node* _add = _internal_add_constraint_deps(); // @@protoc_insertion_point(field_add:pg_query.Query.constraint_deps) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& Query::constraint_deps() const { // @@protoc_insertion_point(field_list:pg_query.Query.constraint_deps) return _impl_.constraint_deps_; } // repeated .pg_query.Node with_check_options = 38 [json_name = "withCheckOptions"]; inline int Query::_internal_with_check_options_size() const { return _impl_.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() { _impl_.with_check_options_.Clear(); } inline ::pg_query::Node* Query::mutable_with_check_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.Query.with_check_options) return _impl_.with_check_options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* Query::mutable_with_check_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.Query.with_check_options) return &_impl_.with_check_options_; } inline const ::pg_query::Node& Query::_internal_with_check_options(int index) const { return _impl_.with_check_options_.Get(index); } inline const ::pg_query::Node& Query::with_check_options(int index) const { // @@protoc_insertion_point(field_get:pg_query.Query.with_check_options) return _internal_with_check_options(index); } inline ::pg_query::Node* Query::_internal_add_with_check_options() { return _impl_.with_check_options_.Add(); } inline ::pg_query::Node* Query::add_with_check_options() { ::pg_query::Node* _add = _internal_add_with_check_options(); // @@protoc_insertion_point(field_add:pg_query.Query.with_check_options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& Query::with_check_options() const { // @@protoc_insertion_point(field_list:pg_query.Query.with_check_options) return _impl_.with_check_options_; } // int32 stmt_location = 39 [json_name = "stmt_location"]; inline void Query::clear_stmt_location() { _impl_.stmt_location_ = 0; } inline int32_t Query::_internal_stmt_location() const { return _impl_.stmt_location_; } inline int32_t Query::stmt_location() const { // @@protoc_insertion_point(field_get:pg_query.Query.stmt_location) return _internal_stmt_location(); } inline void Query::_internal_set_stmt_location(int32_t value) { _impl_.stmt_location_ = value; } inline void Query::set_stmt_location(int32_t value) { _internal_set_stmt_location(value); // @@protoc_insertion_point(field_set:pg_query.Query.stmt_location) } // int32 stmt_len = 40 [json_name = "stmt_len"]; inline void Query::clear_stmt_len() { _impl_.stmt_len_ = 0; } inline int32_t Query::_internal_stmt_len() const { return _impl_.stmt_len_; } inline int32_t Query::stmt_len() const { // @@protoc_insertion_point(field_get:pg_query.Query.stmt_len) return _internal_stmt_len(); } inline void Query::_internal_set_stmt_len(int32_t value) { _impl_.stmt_len_ = value; } inline void Query::set_stmt_len(int32_t value) { _internal_set_stmt_len(value); // @@protoc_insertion_point(field_set:pg_query.Query.stmt_len) } // ------------------------------------------------------------------- // InsertStmt // .pg_query.RangeVar relation = 1 [json_name = "relation"]; inline bool InsertStmt::_internal_has_relation() const { return this != internal_default_instance() && _impl_.relation_ != nullptr; } inline bool InsertStmt::has_relation() const { return _internal_has_relation(); } inline void InsertStmt::clear_relation() { if (GetArenaForAllocation() == nullptr && _impl_.relation_ != nullptr) { delete _impl_.relation_; } _impl_.relation_ = nullptr; } inline const ::pg_query::RangeVar& InsertStmt::_internal_relation() const { const ::pg_query::RangeVar* p = _impl_.relation_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& InsertStmt::relation() const { // @@protoc_insertion_point(field_get:pg_query.InsertStmt.relation) return _internal_relation(); } inline void InsertStmt::unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.relation_); } _impl_.relation_ = relation; if (relation) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.InsertStmt.relation) } inline ::pg_query::RangeVar* InsertStmt::release_relation() { ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* InsertStmt::unsafe_arena_release_relation() { // @@protoc_insertion_point(field_release:pg_query.InsertStmt.relation) ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; return temp; } inline ::pg_query::RangeVar* InsertStmt::_internal_mutable_relation() { if (_impl_.relation_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.relation_ = p; } return _impl_.relation_; } inline ::pg_query::RangeVar* InsertStmt::mutable_relation() { ::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* relation) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.relation_; } if (relation) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(relation); if (message_arena != submessage_arena) { relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, relation, submessage_arena); } } else { } _impl_.relation_ = relation; // @@protoc_insertion_point(field_set_allocated:pg_query.InsertStmt.relation) } // repeated .pg_query.Node cols = 2 [json_name = "cols"]; inline int InsertStmt::_internal_cols_size() const { return _impl_.cols_.size(); } inline int InsertStmt::cols_size() const { return _internal_cols_size(); } inline void InsertStmt::clear_cols() { _impl_.cols_.Clear(); } inline ::pg_query::Node* InsertStmt::mutable_cols(int index) { // @@protoc_insertion_point(field_mutable:pg_query.InsertStmt.cols) return _impl_.cols_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* InsertStmt::mutable_cols() { // @@protoc_insertion_point(field_mutable_list:pg_query.InsertStmt.cols) return &_impl_.cols_; } inline const ::pg_query::Node& InsertStmt::_internal_cols(int index) const { return _impl_.cols_.Get(index); } inline const ::pg_query::Node& InsertStmt::cols(int index) const { // @@protoc_insertion_point(field_get:pg_query.InsertStmt.cols) return _internal_cols(index); } inline ::pg_query::Node* InsertStmt::_internal_add_cols() { return _impl_.cols_.Add(); } inline ::pg_query::Node* InsertStmt::add_cols() { ::pg_query::Node* _add = _internal_add_cols(); // @@protoc_insertion_point(field_add:pg_query.InsertStmt.cols) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& InsertStmt::cols() const { // @@protoc_insertion_point(field_list:pg_query.InsertStmt.cols) return _impl_.cols_; } // .pg_query.Node select_stmt = 3 [json_name = "selectStmt"]; inline bool InsertStmt::_internal_has_select_stmt() const { return this != internal_default_instance() && _impl_.select_stmt_ != nullptr; } inline bool InsertStmt::has_select_stmt() const { return _internal_has_select_stmt(); } inline void InsertStmt::clear_select_stmt() { if (GetArenaForAllocation() == nullptr && _impl_.select_stmt_ != nullptr) { delete _impl_.select_stmt_; } _impl_.select_stmt_ = nullptr; } inline const ::pg_query::Node& InsertStmt::_internal_select_stmt() const { const ::pg_query::Node* p = _impl_.select_stmt_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& InsertStmt::select_stmt() const { // @@protoc_insertion_point(field_get:pg_query.InsertStmt.select_stmt) return _internal_select_stmt(); } inline void InsertStmt::unsafe_arena_set_allocated_select_stmt( ::pg_query::Node* select_stmt) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.select_stmt_); } _impl_.select_stmt_ = select_stmt; if (select_stmt) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.InsertStmt.select_stmt) } inline ::pg_query::Node* InsertStmt::release_select_stmt() { ::pg_query::Node* temp = _impl_.select_stmt_; _impl_.select_stmt_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* InsertStmt::unsafe_arena_release_select_stmt() { // @@protoc_insertion_point(field_release:pg_query.InsertStmt.select_stmt) ::pg_query::Node* temp = _impl_.select_stmt_; _impl_.select_stmt_ = nullptr; return temp; } inline ::pg_query::Node* InsertStmt::_internal_mutable_select_stmt() { if (_impl_.select_stmt_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.select_stmt_ = p; } return _impl_.select_stmt_; } inline ::pg_query::Node* InsertStmt::mutable_select_stmt() { ::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* select_stmt) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.select_stmt_; } if (select_stmt) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(select_stmt); if (message_arena != submessage_arena) { select_stmt = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, select_stmt, submessage_arena); } } else { } _impl_.select_stmt_ = select_stmt; // @@protoc_insertion_point(field_set_allocated:pg_query.InsertStmt.select_stmt) } // .pg_query.OnConflictClause on_conflict_clause = 4 [json_name = "onConflictClause"]; inline bool InsertStmt::_internal_has_on_conflict_clause() const { return this != internal_default_instance() && _impl_.on_conflict_clause_ != nullptr; } inline bool InsertStmt::has_on_conflict_clause() const { return _internal_has_on_conflict_clause(); } inline void InsertStmt::clear_on_conflict_clause() { if (GetArenaForAllocation() == nullptr && _impl_.on_conflict_clause_ != nullptr) { delete _impl_.on_conflict_clause_; } _impl_.on_conflict_clause_ = nullptr; } inline const ::pg_query::OnConflictClause& InsertStmt::_internal_on_conflict_clause() const { const ::pg_query::OnConflictClause* p = _impl_.on_conflict_clause_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_OnConflictClause_default_instance_); } inline const ::pg_query::OnConflictClause& InsertStmt::on_conflict_clause() const { // @@protoc_insertion_point(field_get:pg_query.InsertStmt.on_conflict_clause) return _internal_on_conflict_clause(); } inline void InsertStmt::unsafe_arena_set_allocated_on_conflict_clause( ::pg_query::OnConflictClause* on_conflict_clause) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.on_conflict_clause_); } _impl_.on_conflict_clause_ = on_conflict_clause; if (on_conflict_clause) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.InsertStmt.on_conflict_clause) } inline ::pg_query::OnConflictClause* InsertStmt::release_on_conflict_clause() { ::pg_query::OnConflictClause* temp = _impl_.on_conflict_clause_; _impl_.on_conflict_clause_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::OnConflictClause* InsertStmt::unsafe_arena_release_on_conflict_clause() { // @@protoc_insertion_point(field_release:pg_query.InsertStmt.on_conflict_clause) ::pg_query::OnConflictClause* temp = _impl_.on_conflict_clause_; _impl_.on_conflict_clause_ = nullptr; return temp; } inline ::pg_query::OnConflictClause* InsertStmt::_internal_mutable_on_conflict_clause() { if (_impl_.on_conflict_clause_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::OnConflictClause>(GetArenaForAllocation()); _impl_.on_conflict_clause_ = p; } return _impl_.on_conflict_clause_; } inline ::pg_query::OnConflictClause* InsertStmt::mutable_on_conflict_clause() { ::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* on_conflict_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.on_conflict_clause_; } if (on_conflict_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(on_conflict_clause); if (message_arena != submessage_arena) { on_conflict_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, on_conflict_clause, submessage_arena); } } else { } _impl_.on_conflict_clause_ = on_conflict_clause; // @@protoc_insertion_point(field_set_allocated:pg_query.InsertStmt.on_conflict_clause) } // repeated .pg_query.Node returning_list = 5 [json_name = "returningList"]; inline int InsertStmt::_internal_returning_list_size() const { return _impl_.returning_list_.size(); } inline int InsertStmt::returning_list_size() const { return _internal_returning_list_size(); } inline void InsertStmt::clear_returning_list() { _impl_.returning_list_.Clear(); } inline ::pg_query::Node* InsertStmt::mutable_returning_list(int index) { // @@protoc_insertion_point(field_mutable:pg_query.InsertStmt.returning_list) return _impl_.returning_list_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* InsertStmt::mutable_returning_list() { // @@protoc_insertion_point(field_mutable_list:pg_query.InsertStmt.returning_list) return &_impl_.returning_list_; } inline const ::pg_query::Node& InsertStmt::_internal_returning_list(int index) const { return _impl_.returning_list_.Get(index); } inline const ::pg_query::Node& InsertStmt::returning_list(int index) const { // @@protoc_insertion_point(field_get:pg_query.InsertStmt.returning_list) return _internal_returning_list(index); } inline ::pg_query::Node* InsertStmt::_internal_add_returning_list() { return _impl_.returning_list_.Add(); } inline ::pg_query::Node* InsertStmt::add_returning_list() { ::pg_query::Node* _add = _internal_add_returning_list(); // @@protoc_insertion_point(field_add:pg_query.InsertStmt.returning_list) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& InsertStmt::returning_list() const { // @@protoc_insertion_point(field_list:pg_query.InsertStmt.returning_list) return _impl_.returning_list_; } // .pg_query.WithClause with_clause = 6 [json_name = "withClause"]; inline bool InsertStmt::_internal_has_with_clause() const { return this != internal_default_instance() && _impl_.with_clause_ != nullptr; } inline bool InsertStmt::has_with_clause() const { return _internal_has_with_clause(); } inline void InsertStmt::clear_with_clause() { if (GetArenaForAllocation() == nullptr && _impl_.with_clause_ != nullptr) { delete _impl_.with_clause_; } _impl_.with_clause_ = nullptr; } inline const ::pg_query::WithClause& InsertStmt::_internal_with_clause() const { const ::pg_query::WithClause* p = _impl_.with_clause_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_WithClause_default_instance_); } inline const ::pg_query::WithClause& InsertStmt::with_clause() const { // @@protoc_insertion_point(field_get:pg_query.InsertStmt.with_clause) return _internal_with_clause(); } inline void InsertStmt::unsafe_arena_set_allocated_with_clause( ::pg_query::WithClause* with_clause) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.with_clause_); } _impl_.with_clause_ = with_clause; if (with_clause) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.InsertStmt.with_clause) } inline ::pg_query::WithClause* InsertStmt::release_with_clause() { ::pg_query::WithClause* temp = _impl_.with_clause_; _impl_.with_clause_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::WithClause* InsertStmt::unsafe_arena_release_with_clause() { // @@protoc_insertion_point(field_release:pg_query.InsertStmt.with_clause) ::pg_query::WithClause* temp = _impl_.with_clause_; _impl_.with_clause_ = nullptr; return temp; } inline ::pg_query::WithClause* InsertStmt::_internal_mutable_with_clause() { if (_impl_.with_clause_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::WithClause>(GetArenaForAllocation()); _impl_.with_clause_ = p; } return _impl_.with_clause_; } inline ::pg_query::WithClause* InsertStmt::mutable_with_clause() { ::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* with_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.with_clause_; } if (with_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(with_clause); if (message_arena != submessage_arena) { with_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, with_clause, submessage_arena); } } else { } _impl_.with_clause_ = with_clause; // @@protoc_insertion_point(field_set_allocated:pg_query.InsertStmt.with_clause) } // .pg_query.OverridingKind override = 7 [json_name = "override"]; inline void InsertStmt::clear_override() { _impl_.override_ = 0; } inline ::pg_query::OverridingKind InsertStmt::_internal_override() const { return static_cast< ::pg_query::OverridingKind >(_impl_.override_); } inline ::pg_query::OverridingKind InsertStmt::override() const { // @@protoc_insertion_point(field_get:pg_query.InsertStmt.override) return _internal_override(); } inline void InsertStmt::_internal_set_override(::pg_query::OverridingKind value) { _impl_.override_ = value; } inline void InsertStmt::set_override(::pg_query::OverridingKind value) { _internal_set_override(value); // @@protoc_insertion_point(field_set:pg_query.InsertStmt.override) } // ------------------------------------------------------------------- // DeleteStmt // .pg_query.RangeVar relation = 1 [json_name = "relation"]; inline bool DeleteStmt::_internal_has_relation() const { return this != internal_default_instance() && _impl_.relation_ != nullptr; } inline bool DeleteStmt::has_relation() const { return _internal_has_relation(); } inline void DeleteStmt::clear_relation() { if (GetArenaForAllocation() == nullptr && _impl_.relation_ != nullptr) { delete _impl_.relation_; } _impl_.relation_ = nullptr; } inline const ::pg_query::RangeVar& DeleteStmt::_internal_relation() const { const ::pg_query::RangeVar* p = _impl_.relation_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& DeleteStmt::relation() const { // @@protoc_insertion_point(field_get:pg_query.DeleteStmt.relation) return _internal_relation(); } inline void DeleteStmt::unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.relation_); } _impl_.relation_ = relation; if (relation) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.DeleteStmt.relation) } inline ::pg_query::RangeVar* DeleteStmt::release_relation() { ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* DeleteStmt::unsafe_arena_release_relation() { // @@protoc_insertion_point(field_release:pg_query.DeleteStmt.relation) ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; return temp; } inline ::pg_query::RangeVar* DeleteStmt::_internal_mutable_relation() { if (_impl_.relation_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.relation_ = p; } return _impl_.relation_; } inline ::pg_query::RangeVar* DeleteStmt::mutable_relation() { ::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* relation) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.relation_; } if (relation) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(relation); if (message_arena != submessage_arena) { relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, relation, submessage_arena); } } else { } _impl_.relation_ = relation; // @@protoc_insertion_point(field_set_allocated:pg_query.DeleteStmt.relation) } // repeated .pg_query.Node using_clause = 2 [json_name = "usingClause"]; inline int DeleteStmt::_internal_using_clause_size() const { return _impl_.using_clause_.size(); } inline int DeleteStmt::using_clause_size() const { return _internal_using_clause_size(); } inline void DeleteStmt::clear_using_clause() { _impl_.using_clause_.Clear(); } inline ::pg_query::Node* DeleteStmt::mutable_using_clause(int index) { // @@protoc_insertion_point(field_mutable:pg_query.DeleteStmt.using_clause) return _impl_.using_clause_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* DeleteStmt::mutable_using_clause() { // @@protoc_insertion_point(field_mutable_list:pg_query.DeleteStmt.using_clause) return &_impl_.using_clause_; } inline const ::pg_query::Node& DeleteStmt::_internal_using_clause(int index) const { return _impl_.using_clause_.Get(index); } inline const ::pg_query::Node& DeleteStmt::using_clause(int index) const { // @@protoc_insertion_point(field_get:pg_query.DeleteStmt.using_clause) return _internal_using_clause(index); } inline ::pg_query::Node* DeleteStmt::_internal_add_using_clause() { return _impl_.using_clause_.Add(); } inline ::pg_query::Node* DeleteStmt::add_using_clause() { ::pg_query::Node* _add = _internal_add_using_clause(); // @@protoc_insertion_point(field_add:pg_query.DeleteStmt.using_clause) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& DeleteStmt::using_clause() const { // @@protoc_insertion_point(field_list:pg_query.DeleteStmt.using_clause) return _impl_.using_clause_; } // .pg_query.Node where_clause = 3 [json_name = "whereClause"]; inline bool DeleteStmt::_internal_has_where_clause() const { return this != internal_default_instance() && _impl_.where_clause_ != nullptr; } inline bool DeleteStmt::has_where_clause() const { return _internal_has_where_clause(); } inline void DeleteStmt::clear_where_clause() { if (GetArenaForAllocation() == nullptr && _impl_.where_clause_ != nullptr) { delete _impl_.where_clause_; } _impl_.where_clause_ = nullptr; } inline const ::pg_query::Node& DeleteStmt::_internal_where_clause() const { const ::pg_query::Node* p = _impl_.where_clause_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& DeleteStmt::where_clause() const { // @@protoc_insertion_point(field_get:pg_query.DeleteStmt.where_clause) return _internal_where_clause(); } inline void DeleteStmt::unsafe_arena_set_allocated_where_clause( ::pg_query::Node* where_clause) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.where_clause_); } _impl_.where_clause_ = where_clause; if (where_clause) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.DeleteStmt.where_clause) } inline ::pg_query::Node* DeleteStmt::release_where_clause() { ::pg_query::Node* temp = _impl_.where_clause_; _impl_.where_clause_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* DeleteStmt::unsafe_arena_release_where_clause() { // @@protoc_insertion_point(field_release:pg_query.DeleteStmt.where_clause) ::pg_query::Node* temp = _impl_.where_clause_; _impl_.where_clause_ = nullptr; return temp; } inline ::pg_query::Node* DeleteStmt::_internal_mutable_where_clause() { if (_impl_.where_clause_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.where_clause_ = p; } return _impl_.where_clause_; } inline ::pg_query::Node* DeleteStmt::mutable_where_clause() { ::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* where_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.where_clause_; } if (where_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(where_clause); if (message_arena != submessage_arena) { where_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, where_clause, submessage_arena); } } else { } _impl_.where_clause_ = where_clause; // @@protoc_insertion_point(field_set_allocated:pg_query.DeleteStmt.where_clause) } // repeated .pg_query.Node returning_list = 4 [json_name = "returningList"]; inline int DeleteStmt::_internal_returning_list_size() const { return _impl_.returning_list_.size(); } inline int DeleteStmt::returning_list_size() const { return _internal_returning_list_size(); } inline void DeleteStmt::clear_returning_list() { _impl_.returning_list_.Clear(); } inline ::pg_query::Node* DeleteStmt::mutable_returning_list(int index) { // @@protoc_insertion_point(field_mutable:pg_query.DeleteStmt.returning_list) return _impl_.returning_list_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* DeleteStmt::mutable_returning_list() { // @@protoc_insertion_point(field_mutable_list:pg_query.DeleteStmt.returning_list) return &_impl_.returning_list_; } inline const ::pg_query::Node& DeleteStmt::_internal_returning_list(int index) const { return _impl_.returning_list_.Get(index); } inline const ::pg_query::Node& DeleteStmt::returning_list(int index) const { // @@protoc_insertion_point(field_get:pg_query.DeleteStmt.returning_list) return _internal_returning_list(index); } inline ::pg_query::Node* DeleteStmt::_internal_add_returning_list() { return _impl_.returning_list_.Add(); } inline ::pg_query::Node* DeleteStmt::add_returning_list() { ::pg_query::Node* _add = _internal_add_returning_list(); // @@protoc_insertion_point(field_add:pg_query.DeleteStmt.returning_list) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& DeleteStmt::returning_list() const { // @@protoc_insertion_point(field_list:pg_query.DeleteStmt.returning_list) return _impl_.returning_list_; } // .pg_query.WithClause with_clause = 5 [json_name = "withClause"]; inline bool DeleteStmt::_internal_has_with_clause() const { return this != internal_default_instance() && _impl_.with_clause_ != nullptr; } inline bool DeleteStmt::has_with_clause() const { return _internal_has_with_clause(); } inline void DeleteStmt::clear_with_clause() { if (GetArenaForAllocation() == nullptr && _impl_.with_clause_ != nullptr) { delete _impl_.with_clause_; } _impl_.with_clause_ = nullptr; } inline const ::pg_query::WithClause& DeleteStmt::_internal_with_clause() const { const ::pg_query::WithClause* p = _impl_.with_clause_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_WithClause_default_instance_); } inline const ::pg_query::WithClause& DeleteStmt::with_clause() const { // @@protoc_insertion_point(field_get:pg_query.DeleteStmt.with_clause) return _internal_with_clause(); } inline void DeleteStmt::unsafe_arena_set_allocated_with_clause( ::pg_query::WithClause* with_clause) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.with_clause_); } _impl_.with_clause_ = with_clause; if (with_clause) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.DeleteStmt.with_clause) } inline ::pg_query::WithClause* DeleteStmt::release_with_clause() { ::pg_query::WithClause* temp = _impl_.with_clause_; _impl_.with_clause_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::WithClause* DeleteStmt::unsafe_arena_release_with_clause() { // @@protoc_insertion_point(field_release:pg_query.DeleteStmt.with_clause) ::pg_query::WithClause* temp = _impl_.with_clause_; _impl_.with_clause_ = nullptr; return temp; } inline ::pg_query::WithClause* DeleteStmt::_internal_mutable_with_clause() { if (_impl_.with_clause_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::WithClause>(GetArenaForAllocation()); _impl_.with_clause_ = p; } return _impl_.with_clause_; } inline ::pg_query::WithClause* DeleteStmt::mutable_with_clause() { ::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* with_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.with_clause_; } if (with_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(with_clause); if (message_arena != submessage_arena) { with_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, with_clause, submessage_arena); } } else { } _impl_.with_clause_ = with_clause; // @@protoc_insertion_point(field_set_allocated:pg_query.DeleteStmt.with_clause) } // ------------------------------------------------------------------- // UpdateStmt // .pg_query.RangeVar relation = 1 [json_name = "relation"]; inline bool UpdateStmt::_internal_has_relation() const { return this != internal_default_instance() && _impl_.relation_ != nullptr; } inline bool UpdateStmt::has_relation() const { return _internal_has_relation(); } inline void UpdateStmt::clear_relation() { if (GetArenaForAllocation() == nullptr && _impl_.relation_ != nullptr) { delete _impl_.relation_; } _impl_.relation_ = nullptr; } inline const ::pg_query::RangeVar& UpdateStmt::_internal_relation() const { const ::pg_query::RangeVar* p = _impl_.relation_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& UpdateStmt::relation() const { // @@protoc_insertion_point(field_get:pg_query.UpdateStmt.relation) return _internal_relation(); } inline void UpdateStmt::unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.relation_); } _impl_.relation_ = relation; if (relation) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.UpdateStmt.relation) } inline ::pg_query::RangeVar* UpdateStmt::release_relation() { ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* UpdateStmt::unsafe_arena_release_relation() { // @@protoc_insertion_point(field_release:pg_query.UpdateStmt.relation) ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; return temp; } inline ::pg_query::RangeVar* UpdateStmt::_internal_mutable_relation() { if (_impl_.relation_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.relation_ = p; } return _impl_.relation_; } inline ::pg_query::RangeVar* UpdateStmt::mutable_relation() { ::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* relation) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.relation_; } if (relation) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(relation); if (message_arena != submessage_arena) { relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, relation, submessage_arena); } } else { } _impl_.relation_ = relation; // @@protoc_insertion_point(field_set_allocated:pg_query.UpdateStmt.relation) } // repeated .pg_query.Node target_list = 2 [json_name = "targetList"]; inline int UpdateStmt::_internal_target_list_size() const { return _impl_.target_list_.size(); } inline int UpdateStmt::target_list_size() const { return _internal_target_list_size(); } inline void UpdateStmt::clear_target_list() { _impl_.target_list_.Clear(); } inline ::pg_query::Node* UpdateStmt::mutable_target_list(int index) { // @@protoc_insertion_point(field_mutable:pg_query.UpdateStmt.target_list) return _impl_.target_list_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* UpdateStmt::mutable_target_list() { // @@protoc_insertion_point(field_mutable_list:pg_query.UpdateStmt.target_list) return &_impl_.target_list_; } inline const ::pg_query::Node& UpdateStmt::_internal_target_list(int index) const { return _impl_.target_list_.Get(index); } inline const ::pg_query::Node& UpdateStmt::target_list(int index) const { // @@protoc_insertion_point(field_get:pg_query.UpdateStmt.target_list) return _internal_target_list(index); } inline ::pg_query::Node* UpdateStmt::_internal_add_target_list() { return _impl_.target_list_.Add(); } inline ::pg_query::Node* UpdateStmt::add_target_list() { ::pg_query::Node* _add = _internal_add_target_list(); // @@protoc_insertion_point(field_add:pg_query.UpdateStmt.target_list) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& UpdateStmt::target_list() const { // @@protoc_insertion_point(field_list:pg_query.UpdateStmt.target_list) return _impl_.target_list_; } // .pg_query.Node where_clause = 3 [json_name = "whereClause"]; inline bool UpdateStmt::_internal_has_where_clause() const { return this != internal_default_instance() && _impl_.where_clause_ != nullptr; } inline bool UpdateStmt::has_where_clause() const { return _internal_has_where_clause(); } inline void UpdateStmt::clear_where_clause() { if (GetArenaForAllocation() == nullptr && _impl_.where_clause_ != nullptr) { delete _impl_.where_clause_; } _impl_.where_clause_ = nullptr; } inline const ::pg_query::Node& UpdateStmt::_internal_where_clause() const { const ::pg_query::Node* p = _impl_.where_clause_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& UpdateStmt::where_clause() const { // @@protoc_insertion_point(field_get:pg_query.UpdateStmt.where_clause) return _internal_where_clause(); } inline void UpdateStmt::unsafe_arena_set_allocated_where_clause( ::pg_query::Node* where_clause) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.where_clause_); } _impl_.where_clause_ = where_clause; if (where_clause) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.UpdateStmt.where_clause) } inline ::pg_query::Node* UpdateStmt::release_where_clause() { ::pg_query::Node* temp = _impl_.where_clause_; _impl_.where_clause_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* UpdateStmt::unsafe_arena_release_where_clause() { // @@protoc_insertion_point(field_release:pg_query.UpdateStmt.where_clause) ::pg_query::Node* temp = _impl_.where_clause_; _impl_.where_clause_ = nullptr; return temp; } inline ::pg_query::Node* UpdateStmt::_internal_mutable_where_clause() { if (_impl_.where_clause_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.where_clause_ = p; } return _impl_.where_clause_; } inline ::pg_query::Node* UpdateStmt::mutable_where_clause() { ::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* where_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.where_clause_; } if (where_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(where_clause); if (message_arena != submessage_arena) { where_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, where_clause, submessage_arena); } } else { } _impl_.where_clause_ = where_clause; // @@protoc_insertion_point(field_set_allocated:pg_query.UpdateStmt.where_clause) } // repeated .pg_query.Node from_clause = 4 [json_name = "fromClause"]; inline int UpdateStmt::_internal_from_clause_size() const { return _impl_.from_clause_.size(); } inline int UpdateStmt::from_clause_size() const { return _internal_from_clause_size(); } inline void UpdateStmt::clear_from_clause() { _impl_.from_clause_.Clear(); } inline ::pg_query::Node* UpdateStmt::mutable_from_clause(int index) { // @@protoc_insertion_point(field_mutable:pg_query.UpdateStmt.from_clause) return _impl_.from_clause_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* UpdateStmt::mutable_from_clause() { // @@protoc_insertion_point(field_mutable_list:pg_query.UpdateStmt.from_clause) return &_impl_.from_clause_; } inline const ::pg_query::Node& UpdateStmt::_internal_from_clause(int index) const { return _impl_.from_clause_.Get(index); } inline const ::pg_query::Node& UpdateStmt::from_clause(int index) const { // @@protoc_insertion_point(field_get:pg_query.UpdateStmt.from_clause) return _internal_from_clause(index); } inline ::pg_query::Node* UpdateStmt::_internal_add_from_clause() { return _impl_.from_clause_.Add(); } inline ::pg_query::Node* UpdateStmt::add_from_clause() { ::pg_query::Node* _add = _internal_add_from_clause(); // @@protoc_insertion_point(field_add:pg_query.UpdateStmt.from_clause) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& UpdateStmt::from_clause() const { // @@protoc_insertion_point(field_list:pg_query.UpdateStmt.from_clause) return _impl_.from_clause_; } // repeated .pg_query.Node returning_list = 5 [json_name = "returningList"]; inline int UpdateStmt::_internal_returning_list_size() const { return _impl_.returning_list_.size(); } inline int UpdateStmt::returning_list_size() const { return _internal_returning_list_size(); } inline void UpdateStmt::clear_returning_list() { _impl_.returning_list_.Clear(); } inline ::pg_query::Node* UpdateStmt::mutable_returning_list(int index) { // @@protoc_insertion_point(field_mutable:pg_query.UpdateStmt.returning_list) return _impl_.returning_list_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* UpdateStmt::mutable_returning_list() { // @@protoc_insertion_point(field_mutable_list:pg_query.UpdateStmt.returning_list) return &_impl_.returning_list_; } inline const ::pg_query::Node& UpdateStmt::_internal_returning_list(int index) const { return _impl_.returning_list_.Get(index); } inline const ::pg_query::Node& UpdateStmt::returning_list(int index) const { // @@protoc_insertion_point(field_get:pg_query.UpdateStmt.returning_list) return _internal_returning_list(index); } inline ::pg_query::Node* UpdateStmt::_internal_add_returning_list() { return _impl_.returning_list_.Add(); } inline ::pg_query::Node* UpdateStmt::add_returning_list() { ::pg_query::Node* _add = _internal_add_returning_list(); // @@protoc_insertion_point(field_add:pg_query.UpdateStmt.returning_list) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& UpdateStmt::returning_list() const { // @@protoc_insertion_point(field_list:pg_query.UpdateStmt.returning_list) return _impl_.returning_list_; } // .pg_query.WithClause with_clause = 6 [json_name = "withClause"]; inline bool UpdateStmt::_internal_has_with_clause() const { return this != internal_default_instance() && _impl_.with_clause_ != nullptr; } inline bool UpdateStmt::has_with_clause() const { return _internal_has_with_clause(); } inline void UpdateStmt::clear_with_clause() { if (GetArenaForAllocation() == nullptr && _impl_.with_clause_ != nullptr) { delete _impl_.with_clause_; } _impl_.with_clause_ = nullptr; } inline const ::pg_query::WithClause& UpdateStmt::_internal_with_clause() const { const ::pg_query::WithClause* p = _impl_.with_clause_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_WithClause_default_instance_); } inline const ::pg_query::WithClause& UpdateStmt::with_clause() const { // @@protoc_insertion_point(field_get:pg_query.UpdateStmt.with_clause) return _internal_with_clause(); } inline void UpdateStmt::unsafe_arena_set_allocated_with_clause( ::pg_query::WithClause* with_clause) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.with_clause_); } _impl_.with_clause_ = with_clause; if (with_clause) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.UpdateStmt.with_clause) } inline ::pg_query::WithClause* UpdateStmt::release_with_clause() { ::pg_query::WithClause* temp = _impl_.with_clause_; _impl_.with_clause_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::WithClause* UpdateStmt::unsafe_arena_release_with_clause() { // @@protoc_insertion_point(field_release:pg_query.UpdateStmt.with_clause) ::pg_query::WithClause* temp = _impl_.with_clause_; _impl_.with_clause_ = nullptr; return temp; } inline ::pg_query::WithClause* UpdateStmt::_internal_mutable_with_clause() { if (_impl_.with_clause_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::WithClause>(GetArenaForAllocation()); _impl_.with_clause_ = p; } return _impl_.with_clause_; } inline ::pg_query::WithClause* UpdateStmt::mutable_with_clause() { ::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* with_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.with_clause_; } if (with_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(with_clause); if (message_arena != submessage_arena) { with_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, with_clause, submessage_arena); } } else { } _impl_.with_clause_ = with_clause; // @@protoc_insertion_point(field_set_allocated:pg_query.UpdateStmt.with_clause) } // ------------------------------------------------------------------- // MergeStmt // .pg_query.RangeVar relation = 1 [json_name = "relation"]; inline bool MergeStmt::_internal_has_relation() const { return this != internal_default_instance() && _impl_.relation_ != nullptr; } inline bool MergeStmt::has_relation() const { return _internal_has_relation(); } inline void MergeStmt::clear_relation() { if (GetArenaForAllocation() == nullptr && _impl_.relation_ != nullptr) { delete _impl_.relation_; } _impl_.relation_ = nullptr; } inline const ::pg_query::RangeVar& MergeStmt::_internal_relation() const { const ::pg_query::RangeVar* p = _impl_.relation_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& MergeStmt::relation() const { // @@protoc_insertion_point(field_get:pg_query.MergeStmt.relation) return _internal_relation(); } inline void MergeStmt::unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.relation_); } _impl_.relation_ = relation; if (relation) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.MergeStmt.relation) } inline ::pg_query::RangeVar* MergeStmt::release_relation() { ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* MergeStmt::unsafe_arena_release_relation() { // @@protoc_insertion_point(field_release:pg_query.MergeStmt.relation) ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; return temp; } inline ::pg_query::RangeVar* MergeStmt::_internal_mutable_relation() { if (_impl_.relation_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.relation_ = p; } return _impl_.relation_; } inline ::pg_query::RangeVar* MergeStmt::mutable_relation() { ::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* relation) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.relation_; } if (relation) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(relation); if (message_arena != submessage_arena) { relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, relation, submessage_arena); } } else { } _impl_.relation_ = relation; // @@protoc_insertion_point(field_set_allocated:pg_query.MergeStmt.relation) } // .pg_query.Node source_relation = 2 [json_name = "sourceRelation"]; inline bool MergeStmt::_internal_has_source_relation() const { return this != internal_default_instance() && _impl_.source_relation_ != nullptr; } inline bool MergeStmt::has_source_relation() const { return _internal_has_source_relation(); } inline void MergeStmt::clear_source_relation() { if (GetArenaForAllocation() == nullptr && _impl_.source_relation_ != nullptr) { delete _impl_.source_relation_; } _impl_.source_relation_ = nullptr; } inline const ::pg_query::Node& MergeStmt::_internal_source_relation() const { const ::pg_query::Node* p = _impl_.source_relation_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& MergeStmt::source_relation() const { // @@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* source_relation) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.source_relation_); } _impl_.source_relation_ = source_relation; if (source_relation) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.MergeStmt.source_relation) } inline ::pg_query::Node* MergeStmt::release_source_relation() { ::pg_query::Node* temp = _impl_.source_relation_; _impl_.source_relation_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* MergeStmt::unsafe_arena_release_source_relation() { // @@protoc_insertion_point(field_release:pg_query.MergeStmt.source_relation) ::pg_query::Node* temp = _impl_.source_relation_; _impl_.source_relation_ = nullptr; return temp; } inline ::pg_query::Node* MergeStmt::_internal_mutable_source_relation() { if (_impl_.source_relation_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.source_relation_ = p; } return _impl_.source_relation_; } inline ::pg_query::Node* MergeStmt::mutable_source_relation() { ::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* source_relation) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.source_relation_; } if (source_relation) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(source_relation); if (message_arena != submessage_arena) { source_relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, source_relation, submessage_arena); } } else { } _impl_.source_relation_ = source_relation; // @@protoc_insertion_point(field_set_allocated:pg_query.MergeStmt.source_relation) } // .pg_query.Node join_condition = 3 [json_name = "joinCondition"]; inline bool MergeStmt::_internal_has_join_condition() const { return this != internal_default_instance() && _impl_.join_condition_ != nullptr; } inline bool MergeStmt::has_join_condition() const { return _internal_has_join_condition(); } inline void MergeStmt::clear_join_condition() { if (GetArenaForAllocation() == nullptr && _impl_.join_condition_ != nullptr) { delete _impl_.join_condition_; } _impl_.join_condition_ = nullptr; } inline const ::pg_query::Node& MergeStmt::_internal_join_condition() const { const ::pg_query::Node* p = _impl_.join_condition_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& MergeStmt::join_condition() const { // @@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* join_condition) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.join_condition_); } _impl_.join_condition_ = join_condition; if (join_condition) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.MergeStmt.join_condition) } inline ::pg_query::Node* MergeStmt::release_join_condition() { ::pg_query::Node* temp = _impl_.join_condition_; _impl_.join_condition_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* MergeStmt::unsafe_arena_release_join_condition() { // @@protoc_insertion_point(field_release:pg_query.MergeStmt.join_condition) ::pg_query::Node* temp = _impl_.join_condition_; _impl_.join_condition_ = nullptr; return temp; } inline ::pg_query::Node* MergeStmt::_internal_mutable_join_condition() { if (_impl_.join_condition_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.join_condition_ = p; } return _impl_.join_condition_; } inline ::pg_query::Node* MergeStmt::mutable_join_condition() { ::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* join_condition) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.join_condition_; } if (join_condition) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(join_condition); if (message_arena != submessage_arena) { join_condition = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, join_condition, submessage_arena); } } else { } _impl_.join_condition_ = join_condition; // @@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 _impl_.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() { _impl_.merge_when_clauses_.Clear(); } inline ::pg_query::Node* MergeStmt::mutable_merge_when_clauses(int index) { // @@protoc_insertion_point(field_mutable:pg_query.MergeStmt.merge_when_clauses) return _impl_.merge_when_clauses_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* MergeStmt::mutable_merge_when_clauses() { // @@protoc_insertion_point(field_mutable_list:pg_query.MergeStmt.merge_when_clauses) return &_impl_.merge_when_clauses_; } inline const ::pg_query::Node& MergeStmt::_internal_merge_when_clauses(int index) const { return _impl_.merge_when_clauses_.Get(index); } inline const ::pg_query::Node& MergeStmt::merge_when_clauses(int index) const { // @@protoc_insertion_point(field_get:pg_query.MergeStmt.merge_when_clauses) return _internal_merge_when_clauses(index); } inline ::pg_query::Node* MergeStmt::_internal_add_merge_when_clauses() { return _impl_.merge_when_clauses_.Add(); } inline ::pg_query::Node* MergeStmt::add_merge_when_clauses() { ::pg_query::Node* _add = _internal_add_merge_when_clauses(); // @@protoc_insertion_point(field_add:pg_query.MergeStmt.merge_when_clauses) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& MergeStmt::merge_when_clauses() const { // @@protoc_insertion_point(field_list:pg_query.MergeStmt.merge_when_clauses) return _impl_.merge_when_clauses_; } // .pg_query.WithClause with_clause = 5 [json_name = "withClause"]; inline bool MergeStmt::_internal_has_with_clause() const { return this != internal_default_instance() && _impl_.with_clause_ != nullptr; } inline bool MergeStmt::has_with_clause() const { return _internal_has_with_clause(); } inline void MergeStmt::clear_with_clause() { if (GetArenaForAllocation() == nullptr && _impl_.with_clause_ != nullptr) { delete _impl_.with_clause_; } _impl_.with_clause_ = nullptr; } inline const ::pg_query::WithClause& MergeStmt::_internal_with_clause() const { const ::pg_query::WithClause* p = _impl_.with_clause_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_WithClause_default_instance_); } inline const ::pg_query::WithClause& MergeStmt::with_clause() const { // @@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* with_clause) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.with_clause_); } _impl_.with_clause_ = with_clause; if (with_clause) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.MergeStmt.with_clause) } inline ::pg_query::WithClause* MergeStmt::release_with_clause() { ::pg_query::WithClause* temp = _impl_.with_clause_; _impl_.with_clause_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::WithClause* MergeStmt::unsafe_arena_release_with_clause() { // @@protoc_insertion_point(field_release:pg_query.MergeStmt.with_clause) ::pg_query::WithClause* temp = _impl_.with_clause_; _impl_.with_clause_ = nullptr; return temp; } inline ::pg_query::WithClause* MergeStmt::_internal_mutable_with_clause() { if (_impl_.with_clause_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::WithClause>(GetArenaForAllocation()); _impl_.with_clause_ = p; } return _impl_.with_clause_; } inline ::pg_query::WithClause* MergeStmt::mutable_with_clause() { ::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* with_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.with_clause_; } if (with_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(with_clause); if (message_arena != submessage_arena) { with_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, with_clause, submessage_arena); } } else { } _impl_.with_clause_ = with_clause; // @@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 _impl_.distinct_clause_.size(); } inline int SelectStmt::distinct_clause_size() const { return _internal_distinct_clause_size(); } inline void SelectStmt::clear_distinct_clause() { _impl_.distinct_clause_.Clear(); } inline ::pg_query::Node* SelectStmt::mutable_distinct_clause(int index) { // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.distinct_clause) return _impl_.distinct_clause_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* SelectStmt::mutable_distinct_clause() { // @@protoc_insertion_point(field_mutable_list:pg_query.SelectStmt.distinct_clause) return &_impl_.distinct_clause_; } inline const ::pg_query::Node& SelectStmt::_internal_distinct_clause(int index) const { return _impl_.distinct_clause_.Get(index); } inline const ::pg_query::Node& SelectStmt::distinct_clause(int index) const { // @@protoc_insertion_point(field_get:pg_query.SelectStmt.distinct_clause) return _internal_distinct_clause(index); } inline ::pg_query::Node* SelectStmt::_internal_add_distinct_clause() { return _impl_.distinct_clause_.Add(); } inline ::pg_query::Node* SelectStmt::add_distinct_clause() { ::pg_query::Node* _add = _internal_add_distinct_clause(); // @@protoc_insertion_point(field_add:pg_query.SelectStmt.distinct_clause) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& SelectStmt::distinct_clause() const { // @@protoc_insertion_point(field_list:pg_query.SelectStmt.distinct_clause) return _impl_.distinct_clause_; } // .pg_query.IntoClause into_clause = 2 [json_name = "intoClause"]; inline bool SelectStmt::_internal_has_into_clause() const { return this != internal_default_instance() && _impl_.into_clause_ != nullptr; } inline bool SelectStmt::has_into_clause() const { return _internal_has_into_clause(); } inline void SelectStmt::clear_into_clause() { if (GetArenaForAllocation() == nullptr && _impl_.into_clause_ != nullptr) { delete _impl_.into_clause_; } _impl_.into_clause_ = nullptr; } inline const ::pg_query::IntoClause& SelectStmt::_internal_into_clause() const { const ::pg_query::IntoClause* p = _impl_.into_clause_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_IntoClause_default_instance_); } inline const ::pg_query::IntoClause& SelectStmt::into_clause() const { // @@protoc_insertion_point(field_get:pg_query.SelectStmt.into_clause) return _internal_into_clause(); } inline void SelectStmt::unsafe_arena_set_allocated_into_clause( ::pg_query::IntoClause* into_clause) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.into_clause_); } _impl_.into_clause_ = into_clause; if (into_clause) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SelectStmt.into_clause) } inline ::pg_query::IntoClause* SelectStmt::release_into_clause() { ::pg_query::IntoClause* temp = _impl_.into_clause_; _impl_.into_clause_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::IntoClause* SelectStmt::unsafe_arena_release_into_clause() { // @@protoc_insertion_point(field_release:pg_query.SelectStmt.into_clause) ::pg_query::IntoClause* temp = _impl_.into_clause_; _impl_.into_clause_ = nullptr; return temp; } inline ::pg_query::IntoClause* SelectStmt::_internal_mutable_into_clause() { if (_impl_.into_clause_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::IntoClause>(GetArenaForAllocation()); _impl_.into_clause_ = p; } return _impl_.into_clause_; } inline ::pg_query::IntoClause* SelectStmt::mutable_into_clause() { ::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* into_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.into_clause_; } if (into_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(into_clause); if (message_arena != submessage_arena) { into_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, into_clause, submessage_arena); } } else { } _impl_.into_clause_ = into_clause; // @@protoc_insertion_point(field_set_allocated:pg_query.SelectStmt.into_clause) } // repeated .pg_query.Node target_list = 3 [json_name = "targetList"]; inline int SelectStmt::_internal_target_list_size() const { return _impl_.target_list_.size(); } inline int SelectStmt::target_list_size() const { return _internal_target_list_size(); } inline void SelectStmt::clear_target_list() { _impl_.target_list_.Clear(); } inline ::pg_query::Node* SelectStmt::mutable_target_list(int index) { // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.target_list) return _impl_.target_list_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* SelectStmt::mutable_target_list() { // @@protoc_insertion_point(field_mutable_list:pg_query.SelectStmt.target_list) return &_impl_.target_list_; } inline const ::pg_query::Node& SelectStmt::_internal_target_list(int index) const { return _impl_.target_list_.Get(index); } inline const ::pg_query::Node& SelectStmt::target_list(int index) const { // @@protoc_insertion_point(field_get:pg_query.SelectStmt.target_list) return _internal_target_list(index); } inline ::pg_query::Node* SelectStmt::_internal_add_target_list() { return _impl_.target_list_.Add(); } inline ::pg_query::Node* SelectStmt::add_target_list() { ::pg_query::Node* _add = _internal_add_target_list(); // @@protoc_insertion_point(field_add:pg_query.SelectStmt.target_list) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& SelectStmt::target_list() const { // @@protoc_insertion_point(field_list:pg_query.SelectStmt.target_list) return _impl_.target_list_; } // repeated .pg_query.Node from_clause = 4 [json_name = "fromClause"]; inline int SelectStmt::_internal_from_clause_size() const { return _impl_.from_clause_.size(); } inline int SelectStmt::from_clause_size() const { return _internal_from_clause_size(); } inline void SelectStmt::clear_from_clause() { _impl_.from_clause_.Clear(); } inline ::pg_query::Node* SelectStmt::mutable_from_clause(int index) { // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.from_clause) return _impl_.from_clause_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* SelectStmt::mutable_from_clause() { // @@protoc_insertion_point(field_mutable_list:pg_query.SelectStmt.from_clause) return &_impl_.from_clause_; } inline const ::pg_query::Node& SelectStmt::_internal_from_clause(int index) const { return _impl_.from_clause_.Get(index); } inline const ::pg_query::Node& SelectStmt::from_clause(int index) const { // @@protoc_insertion_point(field_get:pg_query.SelectStmt.from_clause) return _internal_from_clause(index); } inline ::pg_query::Node* SelectStmt::_internal_add_from_clause() { return _impl_.from_clause_.Add(); } inline ::pg_query::Node* SelectStmt::add_from_clause() { ::pg_query::Node* _add = _internal_add_from_clause(); // @@protoc_insertion_point(field_add:pg_query.SelectStmt.from_clause) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& SelectStmt::from_clause() const { // @@protoc_insertion_point(field_list:pg_query.SelectStmt.from_clause) return _impl_.from_clause_; } // .pg_query.Node where_clause = 5 [json_name = "whereClause"]; inline bool SelectStmt::_internal_has_where_clause() const { return this != internal_default_instance() && _impl_.where_clause_ != nullptr; } inline bool SelectStmt::has_where_clause() const { return _internal_has_where_clause(); } inline void SelectStmt::clear_where_clause() { if (GetArenaForAllocation() == nullptr && _impl_.where_clause_ != nullptr) { delete _impl_.where_clause_; } _impl_.where_clause_ = nullptr; } inline const ::pg_query::Node& SelectStmt::_internal_where_clause() const { const ::pg_query::Node* p = _impl_.where_clause_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& SelectStmt::where_clause() const { // @@protoc_insertion_point(field_get:pg_query.SelectStmt.where_clause) return _internal_where_clause(); } inline void SelectStmt::unsafe_arena_set_allocated_where_clause( ::pg_query::Node* where_clause) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.where_clause_); } _impl_.where_clause_ = where_clause; if (where_clause) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SelectStmt.where_clause) } inline ::pg_query::Node* SelectStmt::release_where_clause() { ::pg_query::Node* temp = _impl_.where_clause_; _impl_.where_clause_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* SelectStmt::unsafe_arena_release_where_clause() { // @@protoc_insertion_point(field_release:pg_query.SelectStmt.where_clause) ::pg_query::Node* temp = _impl_.where_clause_; _impl_.where_clause_ = nullptr; return temp; } inline ::pg_query::Node* SelectStmt::_internal_mutable_where_clause() { if (_impl_.where_clause_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.where_clause_ = p; } return _impl_.where_clause_; } inline ::pg_query::Node* SelectStmt::mutable_where_clause() { ::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* where_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.where_clause_; } if (where_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(where_clause); if (message_arena != submessage_arena) { where_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, where_clause, submessage_arena); } } else { } _impl_.where_clause_ = where_clause; // @@protoc_insertion_point(field_set_allocated:pg_query.SelectStmt.where_clause) } // repeated .pg_query.Node group_clause = 6 [json_name = "groupClause"]; inline int SelectStmt::_internal_group_clause_size() const { return _impl_.group_clause_.size(); } inline int SelectStmt::group_clause_size() const { return _internal_group_clause_size(); } inline void SelectStmt::clear_group_clause() { _impl_.group_clause_.Clear(); } inline ::pg_query::Node* SelectStmt::mutable_group_clause(int index) { // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.group_clause) return _impl_.group_clause_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* SelectStmt::mutable_group_clause() { // @@protoc_insertion_point(field_mutable_list:pg_query.SelectStmt.group_clause) return &_impl_.group_clause_; } inline const ::pg_query::Node& SelectStmt::_internal_group_clause(int index) const { return _impl_.group_clause_.Get(index); } inline const ::pg_query::Node& SelectStmt::group_clause(int index) const { // @@protoc_insertion_point(field_get:pg_query.SelectStmt.group_clause) return _internal_group_clause(index); } inline ::pg_query::Node* SelectStmt::_internal_add_group_clause() { return _impl_.group_clause_.Add(); } inline ::pg_query::Node* SelectStmt::add_group_clause() { ::pg_query::Node* _add = _internal_add_group_clause(); // @@protoc_insertion_point(field_add:pg_query.SelectStmt.group_clause) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& SelectStmt::group_clause() const { // @@protoc_insertion_point(field_list:pg_query.SelectStmt.group_clause) return _impl_.group_clause_; } // bool group_distinct = 7 [json_name = "groupDistinct"]; inline void SelectStmt::clear_group_distinct() { _impl_.group_distinct_ = false; } inline bool SelectStmt::_internal_group_distinct() const { return _impl_.group_distinct_; } inline bool SelectStmt::group_distinct() const { // @@protoc_insertion_point(field_get:pg_query.SelectStmt.group_distinct) return _internal_group_distinct(); } inline void SelectStmt::_internal_set_group_distinct(bool value) { _impl_.group_distinct_ = value; } inline void SelectStmt::set_group_distinct(bool value) { _internal_set_group_distinct(value); // @@protoc_insertion_point(field_set:pg_query.SelectStmt.group_distinct) } // .pg_query.Node having_clause = 8 [json_name = "havingClause"]; inline bool SelectStmt::_internal_has_having_clause() const { return this != internal_default_instance() && _impl_.having_clause_ != nullptr; } inline bool SelectStmt::has_having_clause() const { return _internal_has_having_clause(); } inline void SelectStmt::clear_having_clause() { if (GetArenaForAllocation() == nullptr && _impl_.having_clause_ != nullptr) { delete _impl_.having_clause_; } _impl_.having_clause_ = nullptr; } inline const ::pg_query::Node& SelectStmt::_internal_having_clause() const { const ::pg_query::Node* p = _impl_.having_clause_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& SelectStmt::having_clause() const { // @@protoc_insertion_point(field_get:pg_query.SelectStmt.having_clause) return _internal_having_clause(); } inline void SelectStmt::unsafe_arena_set_allocated_having_clause( ::pg_query::Node* having_clause) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.having_clause_); } _impl_.having_clause_ = having_clause; if (having_clause) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SelectStmt.having_clause) } inline ::pg_query::Node* SelectStmt::release_having_clause() { ::pg_query::Node* temp = _impl_.having_clause_; _impl_.having_clause_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* SelectStmt::unsafe_arena_release_having_clause() { // @@protoc_insertion_point(field_release:pg_query.SelectStmt.having_clause) ::pg_query::Node* temp = _impl_.having_clause_; _impl_.having_clause_ = nullptr; return temp; } inline ::pg_query::Node* SelectStmt::_internal_mutable_having_clause() { if (_impl_.having_clause_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.having_clause_ = p; } return _impl_.having_clause_; } inline ::pg_query::Node* SelectStmt::mutable_having_clause() { ::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* having_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.having_clause_; } if (having_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(having_clause); if (message_arena != submessage_arena) { having_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, having_clause, submessage_arena); } } else { } _impl_.having_clause_ = having_clause; // @@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 _impl_.window_clause_.size(); } inline int SelectStmt::window_clause_size() const { return _internal_window_clause_size(); } inline void SelectStmt::clear_window_clause() { _impl_.window_clause_.Clear(); } inline ::pg_query::Node* SelectStmt::mutable_window_clause(int index) { // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.window_clause) return _impl_.window_clause_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* SelectStmt::mutable_window_clause() { // @@protoc_insertion_point(field_mutable_list:pg_query.SelectStmt.window_clause) return &_impl_.window_clause_; } inline const ::pg_query::Node& SelectStmt::_internal_window_clause(int index) const { return _impl_.window_clause_.Get(index); } inline const ::pg_query::Node& SelectStmt::window_clause(int index) const { // @@protoc_insertion_point(field_get:pg_query.SelectStmt.window_clause) return _internal_window_clause(index); } inline ::pg_query::Node* SelectStmt::_internal_add_window_clause() { return _impl_.window_clause_.Add(); } inline ::pg_query::Node* SelectStmt::add_window_clause() { ::pg_query::Node* _add = _internal_add_window_clause(); // @@protoc_insertion_point(field_add:pg_query.SelectStmt.window_clause) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& SelectStmt::window_clause() const { // @@protoc_insertion_point(field_list:pg_query.SelectStmt.window_clause) return _impl_.window_clause_; } // repeated .pg_query.Node values_lists = 10 [json_name = "valuesLists"]; inline int SelectStmt::_internal_values_lists_size() const { return _impl_.values_lists_.size(); } inline int SelectStmt::values_lists_size() const { return _internal_values_lists_size(); } inline void SelectStmt::clear_values_lists() { _impl_.values_lists_.Clear(); } inline ::pg_query::Node* SelectStmt::mutable_values_lists(int index) { // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.values_lists) return _impl_.values_lists_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* SelectStmt::mutable_values_lists() { // @@protoc_insertion_point(field_mutable_list:pg_query.SelectStmt.values_lists) return &_impl_.values_lists_; } inline const ::pg_query::Node& SelectStmt::_internal_values_lists(int index) const { return _impl_.values_lists_.Get(index); } inline const ::pg_query::Node& SelectStmt::values_lists(int index) const { // @@protoc_insertion_point(field_get:pg_query.SelectStmt.values_lists) return _internal_values_lists(index); } inline ::pg_query::Node* SelectStmt::_internal_add_values_lists() { return _impl_.values_lists_.Add(); } inline ::pg_query::Node* SelectStmt::add_values_lists() { ::pg_query::Node* _add = _internal_add_values_lists(); // @@protoc_insertion_point(field_add:pg_query.SelectStmt.values_lists) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& SelectStmt::values_lists() const { // @@protoc_insertion_point(field_list:pg_query.SelectStmt.values_lists) return _impl_.values_lists_; } // repeated .pg_query.Node sort_clause = 11 [json_name = "sortClause"]; inline int SelectStmt::_internal_sort_clause_size() const { return _impl_.sort_clause_.size(); } inline int SelectStmt::sort_clause_size() const { return _internal_sort_clause_size(); } inline void SelectStmt::clear_sort_clause() { _impl_.sort_clause_.Clear(); } inline ::pg_query::Node* SelectStmt::mutable_sort_clause(int index) { // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.sort_clause) return _impl_.sort_clause_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* SelectStmt::mutable_sort_clause() { // @@protoc_insertion_point(field_mutable_list:pg_query.SelectStmt.sort_clause) return &_impl_.sort_clause_; } inline const ::pg_query::Node& SelectStmt::_internal_sort_clause(int index) const { return _impl_.sort_clause_.Get(index); } inline const ::pg_query::Node& SelectStmt::sort_clause(int index) const { // @@protoc_insertion_point(field_get:pg_query.SelectStmt.sort_clause) return _internal_sort_clause(index); } inline ::pg_query::Node* SelectStmt::_internal_add_sort_clause() { return _impl_.sort_clause_.Add(); } inline ::pg_query::Node* SelectStmt::add_sort_clause() { ::pg_query::Node* _add = _internal_add_sort_clause(); // @@protoc_insertion_point(field_add:pg_query.SelectStmt.sort_clause) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& SelectStmt::sort_clause() const { // @@protoc_insertion_point(field_list:pg_query.SelectStmt.sort_clause) return _impl_.sort_clause_; } // .pg_query.Node limit_offset = 12 [json_name = "limitOffset"]; inline bool SelectStmt::_internal_has_limit_offset() const { return this != internal_default_instance() && _impl_.limit_offset_ != nullptr; } inline bool SelectStmt::has_limit_offset() const { return _internal_has_limit_offset(); } inline void SelectStmt::clear_limit_offset() { if (GetArenaForAllocation() == nullptr && _impl_.limit_offset_ != nullptr) { delete _impl_.limit_offset_; } _impl_.limit_offset_ = nullptr; } inline const ::pg_query::Node& SelectStmt::_internal_limit_offset() const { const ::pg_query::Node* p = _impl_.limit_offset_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& SelectStmt::limit_offset() const { // @@protoc_insertion_point(field_get:pg_query.SelectStmt.limit_offset) return _internal_limit_offset(); } inline void SelectStmt::unsafe_arena_set_allocated_limit_offset( ::pg_query::Node* limit_offset) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.limit_offset_); } _impl_.limit_offset_ = limit_offset; if (limit_offset) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SelectStmt.limit_offset) } inline ::pg_query::Node* SelectStmt::release_limit_offset() { ::pg_query::Node* temp = _impl_.limit_offset_; _impl_.limit_offset_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* SelectStmt::unsafe_arena_release_limit_offset() { // @@protoc_insertion_point(field_release:pg_query.SelectStmt.limit_offset) ::pg_query::Node* temp = _impl_.limit_offset_; _impl_.limit_offset_ = nullptr; return temp; } inline ::pg_query::Node* SelectStmt::_internal_mutable_limit_offset() { if (_impl_.limit_offset_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.limit_offset_ = p; } return _impl_.limit_offset_; } inline ::pg_query::Node* SelectStmt::mutable_limit_offset() { ::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* limit_offset) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.limit_offset_; } if (limit_offset) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(limit_offset); if (message_arena != submessage_arena) { limit_offset = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, limit_offset, submessage_arena); } } else { } _impl_.limit_offset_ = limit_offset; // @@protoc_insertion_point(field_set_allocated:pg_query.SelectStmt.limit_offset) } // .pg_query.Node limit_count = 13 [json_name = "limitCount"]; inline bool SelectStmt::_internal_has_limit_count() const { return this != internal_default_instance() && _impl_.limit_count_ != nullptr; } inline bool SelectStmt::has_limit_count() const { return _internal_has_limit_count(); } inline void SelectStmt::clear_limit_count() { if (GetArenaForAllocation() == nullptr && _impl_.limit_count_ != nullptr) { delete _impl_.limit_count_; } _impl_.limit_count_ = nullptr; } inline const ::pg_query::Node& SelectStmt::_internal_limit_count() const { const ::pg_query::Node* p = _impl_.limit_count_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& SelectStmt::limit_count() const { // @@protoc_insertion_point(field_get:pg_query.SelectStmt.limit_count) return _internal_limit_count(); } inline void SelectStmt::unsafe_arena_set_allocated_limit_count( ::pg_query::Node* limit_count) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.limit_count_); } _impl_.limit_count_ = limit_count; if (limit_count) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SelectStmt.limit_count) } inline ::pg_query::Node* SelectStmt::release_limit_count() { ::pg_query::Node* temp = _impl_.limit_count_; _impl_.limit_count_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* SelectStmt::unsafe_arena_release_limit_count() { // @@protoc_insertion_point(field_release:pg_query.SelectStmt.limit_count) ::pg_query::Node* temp = _impl_.limit_count_; _impl_.limit_count_ = nullptr; return temp; } inline ::pg_query::Node* SelectStmt::_internal_mutable_limit_count() { if (_impl_.limit_count_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.limit_count_ = p; } return _impl_.limit_count_; } inline ::pg_query::Node* SelectStmt::mutable_limit_count() { ::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* limit_count) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.limit_count_; } if (limit_count) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(limit_count); if (message_arena != submessage_arena) { limit_count = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, limit_count, submessage_arena); } } else { } _impl_.limit_count_ = limit_count; // @@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() { _impl_.limit_option_ = 0; } inline ::pg_query::LimitOption SelectStmt::_internal_limit_option() const { return static_cast< ::pg_query::LimitOption >(_impl_.limit_option_); } inline ::pg_query::LimitOption SelectStmt::limit_option() const { // @@protoc_insertion_point(field_get:pg_query.SelectStmt.limit_option) return _internal_limit_option(); } inline void SelectStmt::_internal_set_limit_option(::pg_query::LimitOption value) { _impl_.limit_option_ = value; } inline void SelectStmt::set_limit_option(::pg_query::LimitOption value) { _internal_set_limit_option(value); // @@protoc_insertion_point(field_set:pg_query.SelectStmt.limit_option) } // repeated .pg_query.Node locking_clause = 15 [json_name = "lockingClause"]; inline int SelectStmt::_internal_locking_clause_size() const { return _impl_.locking_clause_.size(); } inline int SelectStmt::locking_clause_size() const { return _internal_locking_clause_size(); } inline void SelectStmt::clear_locking_clause() { _impl_.locking_clause_.Clear(); } inline ::pg_query::Node* SelectStmt::mutable_locking_clause(int index) { // @@protoc_insertion_point(field_mutable:pg_query.SelectStmt.locking_clause) return _impl_.locking_clause_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* SelectStmt::mutable_locking_clause() { // @@protoc_insertion_point(field_mutable_list:pg_query.SelectStmt.locking_clause) return &_impl_.locking_clause_; } inline const ::pg_query::Node& SelectStmt::_internal_locking_clause(int index) const { return _impl_.locking_clause_.Get(index); } inline const ::pg_query::Node& SelectStmt::locking_clause(int index) const { // @@protoc_insertion_point(field_get:pg_query.SelectStmt.locking_clause) return _internal_locking_clause(index); } inline ::pg_query::Node* SelectStmt::_internal_add_locking_clause() { return _impl_.locking_clause_.Add(); } inline ::pg_query::Node* SelectStmt::add_locking_clause() { ::pg_query::Node* _add = _internal_add_locking_clause(); // @@protoc_insertion_point(field_add:pg_query.SelectStmt.locking_clause) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& SelectStmt::locking_clause() const { // @@protoc_insertion_point(field_list:pg_query.SelectStmt.locking_clause) return _impl_.locking_clause_; } // .pg_query.WithClause with_clause = 16 [json_name = "withClause"]; inline bool SelectStmt::_internal_has_with_clause() const { return this != internal_default_instance() && _impl_.with_clause_ != nullptr; } inline bool SelectStmt::has_with_clause() const { return _internal_has_with_clause(); } inline void SelectStmt::clear_with_clause() { if (GetArenaForAllocation() == nullptr && _impl_.with_clause_ != nullptr) { delete _impl_.with_clause_; } _impl_.with_clause_ = nullptr; } inline const ::pg_query::WithClause& SelectStmt::_internal_with_clause() const { const ::pg_query::WithClause* p = _impl_.with_clause_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_WithClause_default_instance_); } inline const ::pg_query::WithClause& SelectStmt::with_clause() const { // @@protoc_insertion_point(field_get:pg_query.SelectStmt.with_clause) return _internal_with_clause(); } inline void SelectStmt::unsafe_arena_set_allocated_with_clause( ::pg_query::WithClause* with_clause) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.with_clause_); } _impl_.with_clause_ = with_clause; if (with_clause) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SelectStmt.with_clause) } inline ::pg_query::WithClause* SelectStmt::release_with_clause() { ::pg_query::WithClause* temp = _impl_.with_clause_; _impl_.with_clause_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::WithClause* SelectStmt::unsafe_arena_release_with_clause() { // @@protoc_insertion_point(field_release:pg_query.SelectStmt.with_clause) ::pg_query::WithClause* temp = _impl_.with_clause_; _impl_.with_clause_ = nullptr; return temp; } inline ::pg_query::WithClause* SelectStmt::_internal_mutable_with_clause() { if (_impl_.with_clause_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::WithClause>(GetArenaForAllocation()); _impl_.with_clause_ = p; } return _impl_.with_clause_; } inline ::pg_query::WithClause* SelectStmt::mutable_with_clause() { ::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* with_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.with_clause_; } if (with_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(with_clause); if (message_arena != submessage_arena) { with_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, with_clause, submessage_arena); } } else { } _impl_.with_clause_ = with_clause; // @@protoc_insertion_point(field_set_allocated:pg_query.SelectStmt.with_clause) } // .pg_query.SetOperation op = 17 [json_name = "op"]; inline void SelectStmt::clear_op() { _impl_.op_ = 0; } inline ::pg_query::SetOperation SelectStmt::_internal_op() const { return static_cast< ::pg_query::SetOperation >(_impl_.op_); } inline ::pg_query::SetOperation SelectStmt::op() const { // @@protoc_insertion_point(field_get:pg_query.SelectStmt.op) return _internal_op(); } inline void SelectStmt::_internal_set_op(::pg_query::SetOperation value) { _impl_.op_ = value; } inline void SelectStmt::set_op(::pg_query::SetOperation value) { _internal_set_op(value); // @@protoc_insertion_point(field_set:pg_query.SelectStmt.op) } // bool all = 18 [json_name = "all"]; inline void SelectStmt::clear_all() { _impl_.all_ = false; } inline bool SelectStmt::_internal_all() const { return _impl_.all_; } inline bool SelectStmt::all() const { // @@protoc_insertion_point(field_get:pg_query.SelectStmt.all) return _internal_all(); } inline void SelectStmt::_internal_set_all(bool value) { _impl_.all_ = value; } inline void SelectStmt::set_all(bool value) { _internal_set_all(value); // @@protoc_insertion_point(field_set:pg_query.SelectStmt.all) } // .pg_query.SelectStmt larg = 19 [json_name = "larg"]; inline bool SelectStmt::_internal_has_larg() const { return this != internal_default_instance() && _impl_.larg_ != nullptr; } inline bool SelectStmt::has_larg() const { return _internal_has_larg(); } inline void SelectStmt::clear_larg() { if (GetArenaForAllocation() == nullptr && _impl_.larg_ != nullptr) { delete _impl_.larg_; } _impl_.larg_ = nullptr; } inline const ::pg_query::SelectStmt& SelectStmt::_internal_larg() const { const ::pg_query::SelectStmt* p = _impl_.larg_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_SelectStmt_default_instance_); } inline const ::pg_query::SelectStmt& SelectStmt::larg() const { // @@protoc_insertion_point(field_get:pg_query.SelectStmt.larg) return _internal_larg(); } inline void SelectStmt::unsafe_arena_set_allocated_larg( ::pg_query::SelectStmt* larg) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.larg_); } _impl_.larg_ = larg; if (larg) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SelectStmt.larg) } inline ::pg_query::SelectStmt* SelectStmt::release_larg() { ::pg_query::SelectStmt* temp = _impl_.larg_; _impl_.larg_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::SelectStmt* SelectStmt::unsafe_arena_release_larg() { // @@protoc_insertion_point(field_release:pg_query.SelectStmt.larg) ::pg_query::SelectStmt* temp = _impl_.larg_; _impl_.larg_ = nullptr; return temp; } inline ::pg_query::SelectStmt* SelectStmt::_internal_mutable_larg() { if (_impl_.larg_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::SelectStmt>(GetArenaForAllocation()); _impl_.larg_ = p; } return _impl_.larg_; } inline ::pg_query::SelectStmt* SelectStmt::mutable_larg() { ::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* larg) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.larg_; } if (larg) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(larg); if (message_arena != submessage_arena) { larg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, larg, submessage_arena); } } else { } _impl_.larg_ = larg; // @@protoc_insertion_point(field_set_allocated:pg_query.SelectStmt.larg) } // .pg_query.SelectStmt rarg = 20 [json_name = "rarg"]; inline bool SelectStmt::_internal_has_rarg() const { return this != internal_default_instance() && _impl_.rarg_ != nullptr; } inline bool SelectStmt::has_rarg() const { return _internal_has_rarg(); } inline void SelectStmt::clear_rarg() { if (GetArenaForAllocation() == nullptr && _impl_.rarg_ != nullptr) { delete _impl_.rarg_; } _impl_.rarg_ = nullptr; } inline const ::pg_query::SelectStmt& SelectStmt::_internal_rarg() const { const ::pg_query::SelectStmt* p = _impl_.rarg_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_SelectStmt_default_instance_); } inline const ::pg_query::SelectStmt& SelectStmt::rarg() const { // @@protoc_insertion_point(field_get:pg_query.SelectStmt.rarg) return _internal_rarg(); } inline void SelectStmt::unsafe_arena_set_allocated_rarg( ::pg_query::SelectStmt* rarg) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.rarg_); } _impl_.rarg_ = rarg; if (rarg) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SelectStmt.rarg) } inline ::pg_query::SelectStmt* SelectStmt::release_rarg() { ::pg_query::SelectStmt* temp = _impl_.rarg_; _impl_.rarg_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::SelectStmt* SelectStmt::unsafe_arena_release_rarg() { // @@protoc_insertion_point(field_release:pg_query.SelectStmt.rarg) ::pg_query::SelectStmt* temp = _impl_.rarg_; _impl_.rarg_ = nullptr; return temp; } inline ::pg_query::SelectStmt* SelectStmt::_internal_mutable_rarg() { if (_impl_.rarg_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::SelectStmt>(GetArenaForAllocation()); _impl_.rarg_ = p; } return _impl_.rarg_; } inline ::pg_query::SelectStmt* SelectStmt::mutable_rarg() { ::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* rarg) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.rarg_; } if (rarg) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(rarg); if (message_arena != submessage_arena) { rarg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, rarg, submessage_arena); } } else { } _impl_.rarg_ = rarg; // @@protoc_insertion_point(field_set_allocated:pg_query.SelectStmt.rarg) } // ------------------------------------------------------------------- // ReturnStmt // .pg_query.Node returnval = 1 [json_name = "returnval"]; inline bool ReturnStmt::_internal_has_returnval() const { return this != internal_default_instance() && _impl_.returnval_ != nullptr; } inline bool ReturnStmt::has_returnval() const { return _internal_has_returnval(); } inline void ReturnStmt::clear_returnval() { if (GetArenaForAllocation() == nullptr && _impl_.returnval_ != nullptr) { delete _impl_.returnval_; } _impl_.returnval_ = nullptr; } inline const ::pg_query::Node& ReturnStmt::_internal_returnval() const { const ::pg_query::Node* p = _impl_.returnval_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& ReturnStmt::returnval() const { // @@protoc_insertion_point(field_get:pg_query.ReturnStmt.returnval) return _internal_returnval(); } inline void ReturnStmt::unsafe_arena_set_allocated_returnval( ::pg_query::Node* returnval) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.returnval_); } _impl_.returnval_ = returnval; if (returnval) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ReturnStmt.returnval) } inline ::pg_query::Node* ReturnStmt::release_returnval() { ::pg_query::Node* temp = _impl_.returnval_; _impl_.returnval_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* ReturnStmt::unsafe_arena_release_returnval() { // @@protoc_insertion_point(field_release:pg_query.ReturnStmt.returnval) ::pg_query::Node* temp = _impl_.returnval_; _impl_.returnval_ = nullptr; return temp; } inline ::pg_query::Node* ReturnStmt::_internal_mutable_returnval() { if (_impl_.returnval_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.returnval_ = p; } return _impl_.returnval_; } inline ::pg_query::Node* ReturnStmt::mutable_returnval() { ::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* returnval) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.returnval_; } if (returnval) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(returnval); if (message_arena != submessage_arena) { returnval = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, returnval, submessage_arena); } } else { } _impl_.returnval_ = returnval; // @@protoc_insertion_point(field_set_allocated:pg_query.ReturnStmt.returnval) } // ------------------------------------------------------------------- // PLAssignStmt // string name = 1 [json_name = "name"]; inline void PLAssignStmt::clear_name() { _impl_.name_.ClearToEmpty(); } inline const std::string& PLAssignStmt::name() const { // @@protoc_insertion_point(field_get:pg_query.PLAssignStmt.name) return _internal_name(); } template inline PROTOBUF_ALWAYS_INLINE void PLAssignStmt::set_name(ArgT0&& arg0, ArgT... args) { _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.PLAssignStmt.name) } inline std::string* PLAssignStmt::mutable_name() { 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 { return _impl_.name_.Get(); } inline void PLAssignStmt::_internal_set_name(const std::string& value) { _impl_.name_.Set(value, GetArenaForAllocation()); } inline std::string* PLAssignStmt::_internal_mutable_name() { return _impl_.name_.Mutable(GetArenaForAllocation()); } inline std::string* PLAssignStmt::release_name() { // @@protoc_insertion_point(field_release:pg_query.PLAssignStmt.name) return _impl_.name_.Release(); } inline void PLAssignStmt::set_allocated_name(std::string* name) { if (name != nullptr) { } else { } _impl_.name_.SetAllocated(name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.name_.IsDefault()) { _impl_.name_.Set("", GetArenaForAllocation()); } #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 _impl_.indirection_.size(); } inline int PLAssignStmt::indirection_size() const { return _internal_indirection_size(); } inline void PLAssignStmt::clear_indirection() { _impl_.indirection_.Clear(); } inline ::pg_query::Node* PLAssignStmt::mutable_indirection(int index) { // @@protoc_insertion_point(field_mutable:pg_query.PLAssignStmt.indirection) return _impl_.indirection_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* PLAssignStmt::mutable_indirection() { // @@protoc_insertion_point(field_mutable_list:pg_query.PLAssignStmt.indirection) return &_impl_.indirection_; } inline const ::pg_query::Node& PLAssignStmt::_internal_indirection(int index) const { return _impl_.indirection_.Get(index); } inline const ::pg_query::Node& PLAssignStmt::indirection(int index) const { // @@protoc_insertion_point(field_get:pg_query.PLAssignStmt.indirection) return _internal_indirection(index); } inline ::pg_query::Node* PLAssignStmt::_internal_add_indirection() { return _impl_.indirection_.Add(); } inline ::pg_query::Node* PLAssignStmt::add_indirection() { ::pg_query::Node* _add = _internal_add_indirection(); // @@protoc_insertion_point(field_add:pg_query.PLAssignStmt.indirection) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& PLAssignStmt::indirection() const { // @@protoc_insertion_point(field_list:pg_query.PLAssignStmt.indirection) return _impl_.indirection_; } // int32 nnames = 3 [json_name = "nnames"]; inline void PLAssignStmt::clear_nnames() { _impl_.nnames_ = 0; } inline int32_t PLAssignStmt::_internal_nnames() const { return _impl_.nnames_; } inline int32_t PLAssignStmt::nnames() const { // @@protoc_insertion_point(field_get:pg_query.PLAssignStmt.nnames) return _internal_nnames(); } inline void PLAssignStmt::_internal_set_nnames(int32_t value) { _impl_.nnames_ = value; } inline void PLAssignStmt::set_nnames(int32_t value) { _internal_set_nnames(value); // @@protoc_insertion_point(field_set:pg_query.PLAssignStmt.nnames) } // .pg_query.SelectStmt val = 4 [json_name = "val"]; inline bool PLAssignStmt::_internal_has_val() const { return this != internal_default_instance() && _impl_.val_ != nullptr; } inline bool PLAssignStmt::has_val() const { return _internal_has_val(); } inline void PLAssignStmt::clear_val() { if (GetArenaForAllocation() == nullptr && _impl_.val_ != nullptr) { delete _impl_.val_; } _impl_.val_ = nullptr; } inline const ::pg_query::SelectStmt& PLAssignStmt::_internal_val() const { const ::pg_query::SelectStmt* p = _impl_.val_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_SelectStmt_default_instance_); } inline const ::pg_query::SelectStmt& PLAssignStmt::val() const { // @@protoc_insertion_point(field_get:pg_query.PLAssignStmt.val) return _internal_val(); } inline void PLAssignStmt::unsafe_arena_set_allocated_val( ::pg_query::SelectStmt* val) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.val_); } _impl_.val_ = val; if (val) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.PLAssignStmt.val) } inline ::pg_query::SelectStmt* PLAssignStmt::release_val() { ::pg_query::SelectStmt* temp = _impl_.val_; _impl_.val_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::SelectStmt* PLAssignStmt::unsafe_arena_release_val() { // @@protoc_insertion_point(field_release:pg_query.PLAssignStmt.val) ::pg_query::SelectStmt* temp = _impl_.val_; _impl_.val_ = nullptr; return temp; } inline ::pg_query::SelectStmt* PLAssignStmt::_internal_mutable_val() { if (_impl_.val_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::SelectStmt>(GetArenaForAllocation()); _impl_.val_ = p; } return _impl_.val_; } inline ::pg_query::SelectStmt* PLAssignStmt::mutable_val() { ::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* val) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.val_; } if (val) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(val); if (message_arena != submessage_arena) { val = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, val, submessage_arena); } } else { } _impl_.val_ = val; // @@protoc_insertion_point(field_set_allocated:pg_query.PLAssignStmt.val) } // int32 location = 5 [json_name = "location"]; inline void PLAssignStmt::clear_location() { _impl_.location_ = 0; } inline int32_t PLAssignStmt::_internal_location() const { return _impl_.location_; } inline int32_t PLAssignStmt::location() const { // @@protoc_insertion_point(field_get:pg_query.PLAssignStmt.location) return _internal_location(); } inline void PLAssignStmt::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void PLAssignStmt::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.PLAssignStmt.location) } // ------------------------------------------------------------------- // AlterTableStmt // .pg_query.RangeVar relation = 1 [json_name = "relation"]; inline bool AlterTableStmt::_internal_has_relation() const { return this != internal_default_instance() && _impl_.relation_ != nullptr; } inline bool AlterTableStmt::has_relation() const { return _internal_has_relation(); } inline void AlterTableStmt::clear_relation() { if (GetArenaForAllocation() == nullptr && _impl_.relation_ != nullptr) { delete _impl_.relation_; } _impl_.relation_ = nullptr; } inline const ::pg_query::RangeVar& AlterTableStmt::_internal_relation() const { const ::pg_query::RangeVar* p = _impl_.relation_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& AlterTableStmt::relation() const { // @@protoc_insertion_point(field_get:pg_query.AlterTableStmt.relation) return _internal_relation(); } inline void AlterTableStmt::unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.relation_); } _impl_.relation_ = relation; if (relation) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterTableStmt.relation) } inline ::pg_query::RangeVar* AlterTableStmt::release_relation() { ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* AlterTableStmt::unsafe_arena_release_relation() { // @@protoc_insertion_point(field_release:pg_query.AlterTableStmt.relation) ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; return temp; } inline ::pg_query::RangeVar* AlterTableStmt::_internal_mutable_relation() { if (_impl_.relation_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.relation_ = p; } return _impl_.relation_; } inline ::pg_query::RangeVar* AlterTableStmt::mutable_relation() { ::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* relation) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.relation_; } if (relation) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(relation); if (message_arena != submessage_arena) { relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, relation, submessage_arena); } } else { } _impl_.relation_ = relation; // @@protoc_insertion_point(field_set_allocated:pg_query.AlterTableStmt.relation) } // repeated .pg_query.Node cmds = 2 [json_name = "cmds"]; inline int AlterTableStmt::_internal_cmds_size() const { return _impl_.cmds_.size(); } inline int AlterTableStmt::cmds_size() const { return _internal_cmds_size(); } inline void AlterTableStmt::clear_cmds() { _impl_.cmds_.Clear(); } inline ::pg_query::Node* AlterTableStmt::mutable_cmds(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterTableStmt.cmds) return _impl_.cmds_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterTableStmt::mutable_cmds() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTableStmt.cmds) return &_impl_.cmds_; } inline const ::pg_query::Node& AlterTableStmt::_internal_cmds(int index) const { return _impl_.cmds_.Get(index); } inline const ::pg_query::Node& AlterTableStmt::cmds(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterTableStmt.cmds) return _internal_cmds(index); } inline ::pg_query::Node* AlterTableStmt::_internal_add_cmds() { return _impl_.cmds_.Add(); } inline ::pg_query::Node* AlterTableStmt::add_cmds() { ::pg_query::Node* _add = _internal_add_cmds(); // @@protoc_insertion_point(field_add:pg_query.AlterTableStmt.cmds) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterTableStmt::cmds() const { // @@protoc_insertion_point(field_list:pg_query.AlterTableStmt.cmds) return _impl_.cmds_; } // .pg_query.ObjectType objtype = 3 [json_name = "objtype"]; inline void AlterTableStmt::clear_objtype() { _impl_.objtype_ = 0; } inline ::pg_query::ObjectType AlterTableStmt::_internal_objtype() const { return static_cast< ::pg_query::ObjectType >(_impl_.objtype_); } inline ::pg_query::ObjectType AlterTableStmt::objtype() const { // @@protoc_insertion_point(field_get:pg_query.AlterTableStmt.objtype) return _internal_objtype(); } inline void AlterTableStmt::_internal_set_objtype(::pg_query::ObjectType value) { _impl_.objtype_ = value; } inline void AlterTableStmt::set_objtype(::pg_query::ObjectType value) { _internal_set_objtype(value); // @@protoc_insertion_point(field_set:pg_query.AlterTableStmt.objtype) } // bool missing_ok = 4 [json_name = "missing_ok"]; inline void AlterTableStmt::clear_missing_ok() { _impl_.missing_ok_ = false; } inline bool AlterTableStmt::_internal_missing_ok() const { return _impl_.missing_ok_; } inline bool AlterTableStmt::missing_ok() const { // @@protoc_insertion_point(field_get:pg_query.AlterTableStmt.missing_ok) return _internal_missing_ok(); } inline void AlterTableStmt::_internal_set_missing_ok(bool value) { _impl_.missing_ok_ = value; } inline void AlterTableStmt::set_missing_ok(bool value) { _internal_set_missing_ok(value); // @@protoc_insertion_point(field_set:pg_query.AlterTableStmt.missing_ok) } // ------------------------------------------------------------------- // AlterTableCmd // .pg_query.AlterTableType subtype = 1 [json_name = "subtype"]; inline void AlterTableCmd::clear_subtype() { _impl_.subtype_ = 0; } inline ::pg_query::AlterTableType AlterTableCmd::_internal_subtype() const { return static_cast< ::pg_query::AlterTableType >(_impl_.subtype_); } inline ::pg_query::AlterTableType AlterTableCmd::subtype() const { // @@protoc_insertion_point(field_get:pg_query.AlterTableCmd.subtype) return _internal_subtype(); } inline void AlterTableCmd::_internal_set_subtype(::pg_query::AlterTableType value) { _impl_.subtype_ = value; } inline void AlterTableCmd::set_subtype(::pg_query::AlterTableType value) { _internal_set_subtype(value); // @@protoc_insertion_point(field_set:pg_query.AlterTableCmd.subtype) } // string name = 2 [json_name = "name"]; inline void AlterTableCmd::clear_name() { _impl_.name_.ClearToEmpty(); } inline const std::string& AlterTableCmd::name() const { // @@protoc_insertion_point(field_get:pg_query.AlterTableCmd.name) return _internal_name(); } template inline PROTOBUF_ALWAYS_INLINE void AlterTableCmd::set_name(ArgT0&& arg0, ArgT... args) { _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.AlterTableCmd.name) } inline std::string* AlterTableCmd::mutable_name() { 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 { return _impl_.name_.Get(); } inline void AlterTableCmd::_internal_set_name(const std::string& value) { _impl_.name_.Set(value, GetArenaForAllocation()); } inline std::string* AlterTableCmd::_internal_mutable_name() { return _impl_.name_.Mutable(GetArenaForAllocation()); } inline std::string* AlterTableCmd::release_name() { // @@protoc_insertion_point(field_release:pg_query.AlterTableCmd.name) return _impl_.name_.Release(); } inline void AlterTableCmd::set_allocated_name(std::string* name) { if (name != nullptr) { } else { } _impl_.name_.SetAllocated(name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.name_.IsDefault()) { _impl_.name_.Set("", GetArenaForAllocation()); } #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() { _impl_.num_ = 0; } inline int32_t AlterTableCmd::_internal_num() const { return _impl_.num_; } inline int32_t AlterTableCmd::num() const { // @@protoc_insertion_point(field_get:pg_query.AlterTableCmd.num) return _internal_num(); } inline void AlterTableCmd::_internal_set_num(int32_t value) { _impl_.num_ = value; } inline void AlterTableCmd::set_num(int32_t value) { _internal_set_num(value); // @@protoc_insertion_point(field_set:pg_query.AlterTableCmd.num) } // .pg_query.RoleSpec newowner = 4 [json_name = "newowner"]; inline bool AlterTableCmd::_internal_has_newowner() const { return this != internal_default_instance() && _impl_.newowner_ != nullptr; } inline bool AlterTableCmd::has_newowner() const { return _internal_has_newowner(); } inline void AlterTableCmd::clear_newowner() { if (GetArenaForAllocation() == nullptr && _impl_.newowner_ != nullptr) { delete _impl_.newowner_; } _impl_.newowner_ = nullptr; } inline const ::pg_query::RoleSpec& AlterTableCmd::_internal_newowner() const { const ::pg_query::RoleSpec* p = _impl_.newowner_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RoleSpec_default_instance_); } inline const ::pg_query::RoleSpec& AlterTableCmd::newowner() const { // @@protoc_insertion_point(field_get:pg_query.AlterTableCmd.newowner) return _internal_newowner(); } inline void AlterTableCmd::unsafe_arena_set_allocated_newowner( ::pg_query::RoleSpec* newowner) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.newowner_); } _impl_.newowner_ = newowner; if (newowner) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterTableCmd.newowner) } inline ::pg_query::RoleSpec* AlterTableCmd::release_newowner() { ::pg_query::RoleSpec* temp = _impl_.newowner_; _impl_.newowner_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RoleSpec* AlterTableCmd::unsafe_arena_release_newowner() { // @@protoc_insertion_point(field_release:pg_query.AlterTableCmd.newowner) ::pg_query::RoleSpec* temp = _impl_.newowner_; _impl_.newowner_ = nullptr; return temp; } inline ::pg_query::RoleSpec* AlterTableCmd::_internal_mutable_newowner() { if (_impl_.newowner_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArenaForAllocation()); _impl_.newowner_ = p; } return _impl_.newowner_; } inline ::pg_query::RoleSpec* AlterTableCmd::mutable_newowner() { ::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* newowner) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.newowner_; } if (newowner) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(newowner); if (message_arena != submessage_arena) { newowner = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, newowner, submessage_arena); } } else { } _impl_.newowner_ = newowner; // @@protoc_insertion_point(field_set_allocated:pg_query.AlterTableCmd.newowner) } // .pg_query.Node def = 5 [json_name = "def"]; inline bool AlterTableCmd::_internal_has_def() const { return this != internal_default_instance() && _impl_.def_ != nullptr; } inline bool AlterTableCmd::has_def() const { return _internal_has_def(); } inline void AlterTableCmd::clear_def() { if (GetArenaForAllocation() == nullptr && _impl_.def_ != nullptr) { delete _impl_.def_; } _impl_.def_ = nullptr; } inline const ::pg_query::Node& AlterTableCmd::_internal_def() const { const ::pg_query::Node* p = _impl_.def_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& AlterTableCmd::def() const { // @@protoc_insertion_point(field_get:pg_query.AlterTableCmd.def) return _internal_def(); } inline void AlterTableCmd::unsafe_arena_set_allocated_def( ::pg_query::Node* def) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.def_); } _impl_.def_ = def; if (def) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterTableCmd.def) } inline ::pg_query::Node* AlterTableCmd::release_def() { ::pg_query::Node* temp = _impl_.def_; _impl_.def_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* AlterTableCmd::unsafe_arena_release_def() { // @@protoc_insertion_point(field_release:pg_query.AlterTableCmd.def) ::pg_query::Node* temp = _impl_.def_; _impl_.def_ = nullptr; return temp; } inline ::pg_query::Node* AlterTableCmd::_internal_mutable_def() { if (_impl_.def_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.def_ = p; } return _impl_.def_; } inline ::pg_query::Node* AlterTableCmd::mutable_def() { ::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* def) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.def_; } if (def) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(def); if (message_arena != submessage_arena) { def = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, def, submessage_arena); } } else { } _impl_.def_ = def; // @@protoc_insertion_point(field_set_allocated:pg_query.AlterTableCmd.def) } // .pg_query.DropBehavior behavior = 6 [json_name = "behavior"]; inline void AlterTableCmd::clear_behavior() { _impl_.behavior_ = 0; } inline ::pg_query::DropBehavior AlterTableCmd::_internal_behavior() const { return static_cast< ::pg_query::DropBehavior >(_impl_.behavior_); } inline ::pg_query::DropBehavior AlterTableCmd::behavior() const { // @@protoc_insertion_point(field_get:pg_query.AlterTableCmd.behavior) return _internal_behavior(); } inline void AlterTableCmd::_internal_set_behavior(::pg_query::DropBehavior value) { _impl_.behavior_ = value; } inline void AlterTableCmd::set_behavior(::pg_query::DropBehavior value) { _internal_set_behavior(value); // @@protoc_insertion_point(field_set:pg_query.AlterTableCmd.behavior) } // bool missing_ok = 7 [json_name = "missing_ok"]; inline void AlterTableCmd::clear_missing_ok() { _impl_.missing_ok_ = false; } inline bool AlterTableCmd::_internal_missing_ok() const { return _impl_.missing_ok_; } inline bool AlterTableCmd::missing_ok() const { // @@protoc_insertion_point(field_get:pg_query.AlterTableCmd.missing_ok) return _internal_missing_ok(); } inline void AlterTableCmd::_internal_set_missing_ok(bool value) { _impl_.missing_ok_ = value; } inline void AlterTableCmd::set_missing_ok(bool value) { _internal_set_missing_ok(value); // @@protoc_insertion_point(field_set:pg_query.AlterTableCmd.missing_ok) } // bool recurse = 8 [json_name = "recurse"]; inline void AlterTableCmd::clear_recurse() { _impl_.recurse_ = false; } inline bool AlterTableCmd::_internal_recurse() const { return _impl_.recurse_; } inline bool AlterTableCmd::recurse() const { // @@protoc_insertion_point(field_get:pg_query.AlterTableCmd.recurse) return _internal_recurse(); } inline void AlterTableCmd::_internal_set_recurse(bool value) { _impl_.recurse_ = value; } inline void AlterTableCmd::set_recurse(bool value) { _internal_set_recurse(value); // @@protoc_insertion_point(field_set:pg_query.AlterTableCmd.recurse) } // ------------------------------------------------------------------- // AlterDomainStmt // string subtype = 1 [json_name = "subtype"]; inline void AlterDomainStmt::clear_subtype() { _impl_.subtype_.ClearToEmpty(); } inline const std::string& AlterDomainStmt::subtype() const { // @@protoc_insertion_point(field_get:pg_query.AlterDomainStmt.subtype) return _internal_subtype(); } template inline PROTOBUF_ALWAYS_INLINE void AlterDomainStmt::set_subtype(ArgT0&& arg0, ArgT... args) { _impl_.subtype_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.AlterDomainStmt.subtype) } inline std::string* AlterDomainStmt::mutable_subtype() { 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 { return _impl_.subtype_.Get(); } inline void AlterDomainStmt::_internal_set_subtype(const std::string& value) { _impl_.subtype_.Set(value, GetArenaForAllocation()); } inline std::string* AlterDomainStmt::_internal_mutable_subtype() { return _impl_.subtype_.Mutable(GetArenaForAllocation()); } inline std::string* AlterDomainStmt::release_subtype() { // @@protoc_insertion_point(field_release:pg_query.AlterDomainStmt.subtype) return _impl_.subtype_.Release(); } inline void AlterDomainStmt::set_allocated_subtype(std::string* subtype) { if (subtype != nullptr) { } else { } _impl_.subtype_.SetAllocated(subtype, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.subtype_.IsDefault()) { _impl_.subtype_.Set("", GetArenaForAllocation()); } #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 _impl_.type_name_.size(); } inline int AlterDomainStmt::type_name_size() const { return _internal_type_name_size(); } inline void AlterDomainStmt::clear_type_name() { _impl_.type_name_.Clear(); } inline ::pg_query::Node* AlterDomainStmt::mutable_type_name(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterDomainStmt.type_name) return _impl_.type_name_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterDomainStmt::mutable_type_name() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterDomainStmt.type_name) return &_impl_.type_name_; } inline const ::pg_query::Node& AlterDomainStmt::_internal_type_name(int index) const { return _impl_.type_name_.Get(index); } inline const ::pg_query::Node& AlterDomainStmt::type_name(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterDomainStmt.type_name) return _internal_type_name(index); } inline ::pg_query::Node* AlterDomainStmt::_internal_add_type_name() { return _impl_.type_name_.Add(); } inline ::pg_query::Node* AlterDomainStmt::add_type_name() { ::pg_query::Node* _add = _internal_add_type_name(); // @@protoc_insertion_point(field_add:pg_query.AlterDomainStmt.type_name) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterDomainStmt::type_name() const { // @@protoc_insertion_point(field_list:pg_query.AlterDomainStmt.type_name) return _impl_.type_name_; } // string name = 3 [json_name = "name"]; inline void AlterDomainStmt::clear_name() { _impl_.name_.ClearToEmpty(); } inline const std::string& AlterDomainStmt::name() const { // @@protoc_insertion_point(field_get:pg_query.AlterDomainStmt.name) return _internal_name(); } template inline PROTOBUF_ALWAYS_INLINE void AlterDomainStmt::set_name(ArgT0&& arg0, ArgT... args) { _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.AlterDomainStmt.name) } inline std::string* AlterDomainStmt::mutable_name() { 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 { return _impl_.name_.Get(); } inline void AlterDomainStmt::_internal_set_name(const std::string& value) { _impl_.name_.Set(value, GetArenaForAllocation()); } inline std::string* AlterDomainStmt::_internal_mutable_name() { return _impl_.name_.Mutable(GetArenaForAllocation()); } inline std::string* AlterDomainStmt::release_name() { // @@protoc_insertion_point(field_release:pg_query.AlterDomainStmt.name) return _impl_.name_.Release(); } inline void AlterDomainStmt::set_allocated_name(std::string* name) { if (name != nullptr) { } else { } _impl_.name_.SetAllocated(name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.name_.IsDefault()) { _impl_.name_.Set("", GetArenaForAllocation()); } #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::_internal_has_def() const { return this != internal_default_instance() && _impl_.def_ != nullptr; } inline bool AlterDomainStmt::has_def() const { return _internal_has_def(); } inline void AlterDomainStmt::clear_def() { if (GetArenaForAllocation() == nullptr && _impl_.def_ != nullptr) { delete _impl_.def_; } _impl_.def_ = nullptr; } inline const ::pg_query::Node& AlterDomainStmt::_internal_def() const { const ::pg_query::Node* p = _impl_.def_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& AlterDomainStmt::def() const { // @@protoc_insertion_point(field_get:pg_query.AlterDomainStmt.def) return _internal_def(); } inline void AlterDomainStmt::unsafe_arena_set_allocated_def( ::pg_query::Node* def) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.def_); } _impl_.def_ = def; if (def) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterDomainStmt.def) } inline ::pg_query::Node* AlterDomainStmt::release_def() { ::pg_query::Node* temp = _impl_.def_; _impl_.def_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* AlterDomainStmt::unsafe_arena_release_def() { // @@protoc_insertion_point(field_release:pg_query.AlterDomainStmt.def) ::pg_query::Node* temp = _impl_.def_; _impl_.def_ = nullptr; return temp; } inline ::pg_query::Node* AlterDomainStmt::_internal_mutable_def() { if (_impl_.def_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.def_ = p; } return _impl_.def_; } inline ::pg_query::Node* AlterDomainStmt::mutable_def() { ::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* def) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.def_; } if (def) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(def); if (message_arena != submessage_arena) { def = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, def, submessage_arena); } } else { } _impl_.def_ = def; // @@protoc_insertion_point(field_set_allocated:pg_query.AlterDomainStmt.def) } // .pg_query.DropBehavior behavior = 5 [json_name = "behavior"]; inline void AlterDomainStmt::clear_behavior() { _impl_.behavior_ = 0; } inline ::pg_query::DropBehavior AlterDomainStmt::_internal_behavior() const { return static_cast< ::pg_query::DropBehavior >(_impl_.behavior_); } inline ::pg_query::DropBehavior AlterDomainStmt::behavior() const { // @@protoc_insertion_point(field_get:pg_query.AlterDomainStmt.behavior) return _internal_behavior(); } inline void AlterDomainStmt::_internal_set_behavior(::pg_query::DropBehavior value) { _impl_.behavior_ = value; } inline void AlterDomainStmt::set_behavior(::pg_query::DropBehavior value) { _internal_set_behavior(value); // @@protoc_insertion_point(field_set:pg_query.AlterDomainStmt.behavior) } // bool missing_ok = 6 [json_name = "missing_ok"]; inline void AlterDomainStmt::clear_missing_ok() { _impl_.missing_ok_ = false; } inline bool AlterDomainStmt::_internal_missing_ok() const { return _impl_.missing_ok_; } inline bool AlterDomainStmt::missing_ok() const { // @@protoc_insertion_point(field_get:pg_query.AlterDomainStmt.missing_ok) return _internal_missing_ok(); } inline void AlterDomainStmt::_internal_set_missing_ok(bool value) { _impl_.missing_ok_ = value; } inline void AlterDomainStmt::set_missing_ok(bool value) { _internal_set_missing_ok(value); // @@protoc_insertion_point(field_set:pg_query.AlterDomainStmt.missing_ok) } // ------------------------------------------------------------------- // SetOperationStmt // .pg_query.SetOperation op = 1 [json_name = "op"]; inline void SetOperationStmt::clear_op() { _impl_.op_ = 0; } inline ::pg_query::SetOperation SetOperationStmt::_internal_op() const { return static_cast< ::pg_query::SetOperation >(_impl_.op_); } inline ::pg_query::SetOperation SetOperationStmt::op() const { // @@protoc_insertion_point(field_get:pg_query.SetOperationStmt.op) return _internal_op(); } inline void SetOperationStmt::_internal_set_op(::pg_query::SetOperation value) { _impl_.op_ = value; } inline void SetOperationStmt::set_op(::pg_query::SetOperation value) { _internal_set_op(value); // @@protoc_insertion_point(field_set:pg_query.SetOperationStmt.op) } // bool all = 2 [json_name = "all"]; inline void SetOperationStmt::clear_all() { _impl_.all_ = false; } inline bool SetOperationStmt::_internal_all() const { return _impl_.all_; } inline bool SetOperationStmt::all() const { // @@protoc_insertion_point(field_get:pg_query.SetOperationStmt.all) return _internal_all(); } inline void SetOperationStmt::_internal_set_all(bool value) { _impl_.all_ = value; } inline void SetOperationStmt::set_all(bool value) { _internal_set_all(value); // @@protoc_insertion_point(field_set:pg_query.SetOperationStmt.all) } // .pg_query.Node larg = 3 [json_name = "larg"]; inline bool SetOperationStmt::_internal_has_larg() const { return this != internal_default_instance() && _impl_.larg_ != nullptr; } inline bool SetOperationStmt::has_larg() const { return _internal_has_larg(); } inline void SetOperationStmt::clear_larg() { if (GetArenaForAllocation() == nullptr && _impl_.larg_ != nullptr) { delete _impl_.larg_; } _impl_.larg_ = nullptr; } inline const ::pg_query::Node& SetOperationStmt::_internal_larg() const { const ::pg_query::Node* p = _impl_.larg_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& SetOperationStmt::larg() const { // @@protoc_insertion_point(field_get:pg_query.SetOperationStmt.larg) return _internal_larg(); } inline void SetOperationStmt::unsafe_arena_set_allocated_larg( ::pg_query::Node* larg) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.larg_); } _impl_.larg_ = larg; if (larg) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SetOperationStmt.larg) } inline ::pg_query::Node* SetOperationStmt::release_larg() { ::pg_query::Node* temp = _impl_.larg_; _impl_.larg_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* SetOperationStmt::unsafe_arena_release_larg() { // @@protoc_insertion_point(field_release:pg_query.SetOperationStmt.larg) ::pg_query::Node* temp = _impl_.larg_; _impl_.larg_ = nullptr; return temp; } inline ::pg_query::Node* SetOperationStmt::_internal_mutable_larg() { if (_impl_.larg_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.larg_ = p; } return _impl_.larg_; } inline ::pg_query::Node* SetOperationStmt::mutable_larg() { ::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* larg) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.larg_; } if (larg) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(larg); if (message_arena != submessage_arena) { larg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, larg, submessage_arena); } } else { } _impl_.larg_ = larg; // @@protoc_insertion_point(field_set_allocated:pg_query.SetOperationStmt.larg) } // .pg_query.Node rarg = 4 [json_name = "rarg"]; inline bool SetOperationStmt::_internal_has_rarg() const { return this != internal_default_instance() && _impl_.rarg_ != nullptr; } inline bool SetOperationStmt::has_rarg() const { return _internal_has_rarg(); } inline void SetOperationStmt::clear_rarg() { if (GetArenaForAllocation() == nullptr && _impl_.rarg_ != nullptr) { delete _impl_.rarg_; } _impl_.rarg_ = nullptr; } inline const ::pg_query::Node& SetOperationStmt::_internal_rarg() const { const ::pg_query::Node* p = _impl_.rarg_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& SetOperationStmt::rarg() const { // @@protoc_insertion_point(field_get:pg_query.SetOperationStmt.rarg) return _internal_rarg(); } inline void SetOperationStmt::unsafe_arena_set_allocated_rarg( ::pg_query::Node* rarg) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.rarg_); } _impl_.rarg_ = rarg; if (rarg) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SetOperationStmt.rarg) } inline ::pg_query::Node* SetOperationStmt::release_rarg() { ::pg_query::Node* temp = _impl_.rarg_; _impl_.rarg_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* SetOperationStmt::unsafe_arena_release_rarg() { // @@protoc_insertion_point(field_release:pg_query.SetOperationStmt.rarg) ::pg_query::Node* temp = _impl_.rarg_; _impl_.rarg_ = nullptr; return temp; } inline ::pg_query::Node* SetOperationStmt::_internal_mutable_rarg() { if (_impl_.rarg_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.rarg_ = p; } return _impl_.rarg_; } inline ::pg_query::Node* SetOperationStmt::mutable_rarg() { ::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* rarg) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.rarg_; } if (rarg) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(rarg); if (message_arena != submessage_arena) { rarg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, rarg, submessage_arena); } } else { } _impl_.rarg_ = rarg; // @@protoc_insertion_point(field_set_allocated:pg_query.SetOperationStmt.rarg) } // repeated .pg_query.Node col_types = 5 [json_name = "colTypes"]; inline int SetOperationStmt::_internal_col_types_size() const { return _impl_.col_types_.size(); } inline int SetOperationStmt::col_types_size() const { return _internal_col_types_size(); } inline void SetOperationStmt::clear_col_types() { _impl_.col_types_.Clear(); } inline ::pg_query::Node* SetOperationStmt::mutable_col_types(int index) { // @@protoc_insertion_point(field_mutable:pg_query.SetOperationStmt.col_types) return _impl_.col_types_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* SetOperationStmt::mutable_col_types() { // @@protoc_insertion_point(field_mutable_list:pg_query.SetOperationStmt.col_types) return &_impl_.col_types_; } inline const ::pg_query::Node& SetOperationStmt::_internal_col_types(int index) const { return _impl_.col_types_.Get(index); } inline const ::pg_query::Node& SetOperationStmt::col_types(int index) const { // @@protoc_insertion_point(field_get:pg_query.SetOperationStmt.col_types) return _internal_col_types(index); } inline ::pg_query::Node* SetOperationStmt::_internal_add_col_types() { return _impl_.col_types_.Add(); } inline ::pg_query::Node* SetOperationStmt::add_col_types() { ::pg_query::Node* _add = _internal_add_col_types(); // @@protoc_insertion_point(field_add:pg_query.SetOperationStmt.col_types) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& SetOperationStmt::col_types() const { // @@protoc_insertion_point(field_list:pg_query.SetOperationStmt.col_types) return _impl_.col_types_; } // repeated .pg_query.Node col_typmods = 6 [json_name = "colTypmods"]; inline int SetOperationStmt::_internal_col_typmods_size() const { return _impl_.col_typmods_.size(); } inline int SetOperationStmt::col_typmods_size() const { return _internal_col_typmods_size(); } inline void SetOperationStmt::clear_col_typmods() { _impl_.col_typmods_.Clear(); } inline ::pg_query::Node* SetOperationStmt::mutable_col_typmods(int index) { // @@protoc_insertion_point(field_mutable:pg_query.SetOperationStmt.col_typmods) return _impl_.col_typmods_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* SetOperationStmt::mutable_col_typmods() { // @@protoc_insertion_point(field_mutable_list:pg_query.SetOperationStmt.col_typmods) return &_impl_.col_typmods_; } inline const ::pg_query::Node& SetOperationStmt::_internal_col_typmods(int index) const { return _impl_.col_typmods_.Get(index); } inline const ::pg_query::Node& SetOperationStmt::col_typmods(int index) const { // @@protoc_insertion_point(field_get:pg_query.SetOperationStmt.col_typmods) return _internal_col_typmods(index); } inline ::pg_query::Node* SetOperationStmt::_internal_add_col_typmods() { return _impl_.col_typmods_.Add(); } inline ::pg_query::Node* SetOperationStmt::add_col_typmods() { ::pg_query::Node* _add = _internal_add_col_typmods(); // @@protoc_insertion_point(field_add:pg_query.SetOperationStmt.col_typmods) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& SetOperationStmt::col_typmods() const { // @@protoc_insertion_point(field_list:pg_query.SetOperationStmt.col_typmods) return _impl_.col_typmods_; } // repeated .pg_query.Node col_collations = 7 [json_name = "colCollations"]; inline int SetOperationStmt::_internal_col_collations_size() const { return _impl_.col_collations_.size(); } inline int SetOperationStmt::col_collations_size() const { return _internal_col_collations_size(); } inline void SetOperationStmt::clear_col_collations() { _impl_.col_collations_.Clear(); } inline ::pg_query::Node* SetOperationStmt::mutable_col_collations(int index) { // @@protoc_insertion_point(field_mutable:pg_query.SetOperationStmt.col_collations) return _impl_.col_collations_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* SetOperationStmt::mutable_col_collations() { // @@protoc_insertion_point(field_mutable_list:pg_query.SetOperationStmt.col_collations) return &_impl_.col_collations_; } inline const ::pg_query::Node& SetOperationStmt::_internal_col_collations(int index) const { return _impl_.col_collations_.Get(index); } inline const ::pg_query::Node& SetOperationStmt::col_collations(int index) const { // @@protoc_insertion_point(field_get:pg_query.SetOperationStmt.col_collations) return _internal_col_collations(index); } inline ::pg_query::Node* SetOperationStmt::_internal_add_col_collations() { return _impl_.col_collations_.Add(); } inline ::pg_query::Node* SetOperationStmt::add_col_collations() { ::pg_query::Node* _add = _internal_add_col_collations(); // @@protoc_insertion_point(field_add:pg_query.SetOperationStmt.col_collations) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& SetOperationStmt::col_collations() const { // @@protoc_insertion_point(field_list:pg_query.SetOperationStmt.col_collations) return _impl_.col_collations_; } // repeated .pg_query.Node group_clauses = 8 [json_name = "groupClauses"]; inline int SetOperationStmt::_internal_group_clauses_size() const { return _impl_.group_clauses_.size(); } inline int SetOperationStmt::group_clauses_size() const { return _internal_group_clauses_size(); } inline void SetOperationStmt::clear_group_clauses() { _impl_.group_clauses_.Clear(); } inline ::pg_query::Node* SetOperationStmt::mutable_group_clauses(int index) { // @@protoc_insertion_point(field_mutable:pg_query.SetOperationStmt.group_clauses) return _impl_.group_clauses_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* SetOperationStmt::mutable_group_clauses() { // @@protoc_insertion_point(field_mutable_list:pg_query.SetOperationStmt.group_clauses) return &_impl_.group_clauses_; } inline const ::pg_query::Node& SetOperationStmt::_internal_group_clauses(int index) const { return _impl_.group_clauses_.Get(index); } inline const ::pg_query::Node& SetOperationStmt::group_clauses(int index) const { // @@protoc_insertion_point(field_get:pg_query.SetOperationStmt.group_clauses) return _internal_group_clauses(index); } inline ::pg_query::Node* SetOperationStmt::_internal_add_group_clauses() { return _impl_.group_clauses_.Add(); } inline ::pg_query::Node* SetOperationStmt::add_group_clauses() { ::pg_query::Node* _add = _internal_add_group_clauses(); // @@protoc_insertion_point(field_add:pg_query.SetOperationStmt.group_clauses) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& SetOperationStmt::group_clauses() const { // @@protoc_insertion_point(field_list:pg_query.SetOperationStmt.group_clauses) return _impl_.group_clauses_; } // ------------------------------------------------------------------- // GrantStmt // bool is_grant = 1 [json_name = "is_grant"]; inline void GrantStmt::clear_is_grant() { _impl_.is_grant_ = false; } inline bool GrantStmt::_internal_is_grant() const { return _impl_.is_grant_; } inline bool GrantStmt::is_grant() const { // @@protoc_insertion_point(field_get:pg_query.GrantStmt.is_grant) return _internal_is_grant(); } inline void GrantStmt::_internal_set_is_grant(bool value) { _impl_.is_grant_ = value; } inline void GrantStmt::set_is_grant(bool value) { _internal_set_is_grant(value); // @@protoc_insertion_point(field_set:pg_query.GrantStmt.is_grant) } // .pg_query.GrantTargetType targtype = 2 [json_name = "targtype"]; inline void GrantStmt::clear_targtype() { _impl_.targtype_ = 0; } inline ::pg_query::GrantTargetType GrantStmt::_internal_targtype() const { return static_cast< ::pg_query::GrantTargetType >(_impl_.targtype_); } inline ::pg_query::GrantTargetType GrantStmt::targtype() const { // @@protoc_insertion_point(field_get:pg_query.GrantStmt.targtype) return _internal_targtype(); } inline void GrantStmt::_internal_set_targtype(::pg_query::GrantTargetType value) { _impl_.targtype_ = value; } inline void GrantStmt::set_targtype(::pg_query::GrantTargetType value) { _internal_set_targtype(value); // @@protoc_insertion_point(field_set:pg_query.GrantStmt.targtype) } // .pg_query.ObjectType objtype = 3 [json_name = "objtype"]; inline void GrantStmt::clear_objtype() { _impl_.objtype_ = 0; } inline ::pg_query::ObjectType GrantStmt::_internal_objtype() const { return static_cast< ::pg_query::ObjectType >(_impl_.objtype_); } inline ::pg_query::ObjectType GrantStmt::objtype() const { // @@protoc_insertion_point(field_get:pg_query.GrantStmt.objtype) return _internal_objtype(); } inline void GrantStmt::_internal_set_objtype(::pg_query::ObjectType value) { _impl_.objtype_ = value; } inline void GrantStmt::set_objtype(::pg_query::ObjectType value) { _internal_set_objtype(value); // @@protoc_insertion_point(field_set:pg_query.GrantStmt.objtype) } // repeated .pg_query.Node objects = 4 [json_name = "objects"]; inline int GrantStmt::_internal_objects_size() const { return _impl_.objects_.size(); } inline int GrantStmt::objects_size() const { return _internal_objects_size(); } inline void GrantStmt::clear_objects() { _impl_.objects_.Clear(); } inline ::pg_query::Node* GrantStmt::mutable_objects(int index) { // @@protoc_insertion_point(field_mutable:pg_query.GrantStmt.objects) return _impl_.objects_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* GrantStmt::mutable_objects() { // @@protoc_insertion_point(field_mutable_list:pg_query.GrantStmt.objects) return &_impl_.objects_; } inline const ::pg_query::Node& GrantStmt::_internal_objects(int index) const { return _impl_.objects_.Get(index); } inline const ::pg_query::Node& GrantStmt::objects(int index) const { // @@protoc_insertion_point(field_get:pg_query.GrantStmt.objects) return _internal_objects(index); } inline ::pg_query::Node* GrantStmt::_internal_add_objects() { return _impl_.objects_.Add(); } inline ::pg_query::Node* GrantStmt::add_objects() { ::pg_query::Node* _add = _internal_add_objects(); // @@protoc_insertion_point(field_add:pg_query.GrantStmt.objects) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& GrantStmt::objects() const { // @@protoc_insertion_point(field_list:pg_query.GrantStmt.objects) return _impl_.objects_; } // repeated .pg_query.Node privileges = 5 [json_name = "privileges"]; inline int GrantStmt::_internal_privileges_size() const { return _impl_.privileges_.size(); } inline int GrantStmt::privileges_size() const { return _internal_privileges_size(); } inline void GrantStmt::clear_privileges() { _impl_.privileges_.Clear(); } inline ::pg_query::Node* GrantStmt::mutable_privileges(int index) { // @@protoc_insertion_point(field_mutable:pg_query.GrantStmt.privileges) return _impl_.privileges_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* GrantStmt::mutable_privileges() { // @@protoc_insertion_point(field_mutable_list:pg_query.GrantStmt.privileges) return &_impl_.privileges_; } inline const ::pg_query::Node& GrantStmt::_internal_privileges(int index) const { return _impl_.privileges_.Get(index); } inline const ::pg_query::Node& GrantStmt::privileges(int index) const { // @@protoc_insertion_point(field_get:pg_query.GrantStmt.privileges) return _internal_privileges(index); } inline ::pg_query::Node* GrantStmt::_internal_add_privileges() { return _impl_.privileges_.Add(); } inline ::pg_query::Node* GrantStmt::add_privileges() { ::pg_query::Node* _add = _internal_add_privileges(); // @@protoc_insertion_point(field_add:pg_query.GrantStmt.privileges) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& GrantStmt::privileges() const { // @@protoc_insertion_point(field_list:pg_query.GrantStmt.privileges) return _impl_.privileges_; } // repeated .pg_query.Node grantees = 6 [json_name = "grantees"]; inline int GrantStmt::_internal_grantees_size() const { return _impl_.grantees_.size(); } inline int GrantStmt::grantees_size() const { return _internal_grantees_size(); } inline void GrantStmt::clear_grantees() { _impl_.grantees_.Clear(); } inline ::pg_query::Node* GrantStmt::mutable_grantees(int index) { // @@protoc_insertion_point(field_mutable:pg_query.GrantStmt.grantees) return _impl_.grantees_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* GrantStmt::mutable_grantees() { // @@protoc_insertion_point(field_mutable_list:pg_query.GrantStmt.grantees) return &_impl_.grantees_; } inline const ::pg_query::Node& GrantStmt::_internal_grantees(int index) const { return _impl_.grantees_.Get(index); } inline const ::pg_query::Node& GrantStmt::grantees(int index) const { // @@protoc_insertion_point(field_get:pg_query.GrantStmt.grantees) return _internal_grantees(index); } inline ::pg_query::Node* GrantStmt::_internal_add_grantees() { return _impl_.grantees_.Add(); } inline ::pg_query::Node* GrantStmt::add_grantees() { ::pg_query::Node* _add = _internal_add_grantees(); // @@protoc_insertion_point(field_add:pg_query.GrantStmt.grantees) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& GrantStmt::grantees() const { // @@protoc_insertion_point(field_list:pg_query.GrantStmt.grantees) return _impl_.grantees_; } // bool grant_option = 7 [json_name = "grant_option"]; inline void GrantStmt::clear_grant_option() { _impl_.grant_option_ = false; } inline bool GrantStmt::_internal_grant_option() const { return _impl_.grant_option_; } inline bool GrantStmt::grant_option() const { // @@protoc_insertion_point(field_get:pg_query.GrantStmt.grant_option) return _internal_grant_option(); } inline void GrantStmt::_internal_set_grant_option(bool value) { _impl_.grant_option_ = value; } inline void GrantStmt::set_grant_option(bool value) { _internal_set_grant_option(value); // @@protoc_insertion_point(field_set:pg_query.GrantStmt.grant_option) } // .pg_query.RoleSpec grantor = 8 [json_name = "grantor"]; inline bool GrantStmt::_internal_has_grantor() const { return this != internal_default_instance() && _impl_.grantor_ != nullptr; } inline bool GrantStmt::has_grantor() const { return _internal_has_grantor(); } inline void GrantStmt::clear_grantor() { if (GetArenaForAllocation() == nullptr && _impl_.grantor_ != nullptr) { delete _impl_.grantor_; } _impl_.grantor_ = nullptr; } inline const ::pg_query::RoleSpec& GrantStmt::_internal_grantor() const { const ::pg_query::RoleSpec* p = _impl_.grantor_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RoleSpec_default_instance_); } inline const ::pg_query::RoleSpec& GrantStmt::grantor() const { // @@protoc_insertion_point(field_get:pg_query.GrantStmt.grantor) return _internal_grantor(); } inline void GrantStmt::unsafe_arena_set_allocated_grantor( ::pg_query::RoleSpec* grantor) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.grantor_); } _impl_.grantor_ = grantor; if (grantor) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.GrantStmt.grantor) } inline ::pg_query::RoleSpec* GrantStmt::release_grantor() { ::pg_query::RoleSpec* temp = _impl_.grantor_; _impl_.grantor_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RoleSpec* GrantStmt::unsafe_arena_release_grantor() { // @@protoc_insertion_point(field_release:pg_query.GrantStmt.grantor) ::pg_query::RoleSpec* temp = _impl_.grantor_; _impl_.grantor_ = nullptr; return temp; } inline ::pg_query::RoleSpec* GrantStmt::_internal_mutable_grantor() { if (_impl_.grantor_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArenaForAllocation()); _impl_.grantor_ = p; } return _impl_.grantor_; } inline ::pg_query::RoleSpec* GrantStmt::mutable_grantor() { ::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* grantor) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.grantor_; } if (grantor) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(grantor); if (message_arena != submessage_arena) { grantor = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, grantor, submessage_arena); } } else { } _impl_.grantor_ = grantor; // @@protoc_insertion_point(field_set_allocated:pg_query.GrantStmt.grantor) } // .pg_query.DropBehavior behavior = 9 [json_name = "behavior"]; inline void GrantStmt::clear_behavior() { _impl_.behavior_ = 0; } inline ::pg_query::DropBehavior GrantStmt::_internal_behavior() const { return static_cast< ::pg_query::DropBehavior >(_impl_.behavior_); } inline ::pg_query::DropBehavior GrantStmt::behavior() const { // @@protoc_insertion_point(field_get:pg_query.GrantStmt.behavior) return _internal_behavior(); } inline void GrantStmt::_internal_set_behavior(::pg_query::DropBehavior value) { _impl_.behavior_ = value; } inline void GrantStmt::set_behavior(::pg_query::DropBehavior value) { _internal_set_behavior(value); // @@protoc_insertion_point(field_set:pg_query.GrantStmt.behavior) } // ------------------------------------------------------------------- // GrantRoleStmt // repeated .pg_query.Node granted_roles = 1 [json_name = "granted_roles"]; inline int GrantRoleStmt::_internal_granted_roles_size() const { return _impl_.granted_roles_.size(); } inline int GrantRoleStmt::granted_roles_size() const { return _internal_granted_roles_size(); } inline void GrantRoleStmt::clear_granted_roles() { _impl_.granted_roles_.Clear(); } inline ::pg_query::Node* GrantRoleStmt::mutable_granted_roles(int index) { // @@protoc_insertion_point(field_mutable:pg_query.GrantRoleStmt.granted_roles) return _impl_.granted_roles_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* GrantRoleStmt::mutable_granted_roles() { // @@protoc_insertion_point(field_mutable_list:pg_query.GrantRoleStmt.granted_roles) return &_impl_.granted_roles_; } inline const ::pg_query::Node& GrantRoleStmt::_internal_granted_roles(int index) const { return _impl_.granted_roles_.Get(index); } inline const ::pg_query::Node& GrantRoleStmt::granted_roles(int index) const { // @@protoc_insertion_point(field_get:pg_query.GrantRoleStmt.granted_roles) return _internal_granted_roles(index); } inline ::pg_query::Node* GrantRoleStmt::_internal_add_granted_roles() { return _impl_.granted_roles_.Add(); } inline ::pg_query::Node* GrantRoleStmt::add_granted_roles() { ::pg_query::Node* _add = _internal_add_granted_roles(); // @@protoc_insertion_point(field_add:pg_query.GrantRoleStmt.granted_roles) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& GrantRoleStmt::granted_roles() const { // @@protoc_insertion_point(field_list:pg_query.GrantRoleStmt.granted_roles) return _impl_.granted_roles_; } // repeated .pg_query.Node grantee_roles = 2 [json_name = "grantee_roles"]; inline int GrantRoleStmt::_internal_grantee_roles_size() const { return _impl_.grantee_roles_.size(); } inline int GrantRoleStmt::grantee_roles_size() const { return _internal_grantee_roles_size(); } inline void GrantRoleStmt::clear_grantee_roles() { _impl_.grantee_roles_.Clear(); } inline ::pg_query::Node* GrantRoleStmt::mutable_grantee_roles(int index) { // @@protoc_insertion_point(field_mutable:pg_query.GrantRoleStmt.grantee_roles) return _impl_.grantee_roles_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* GrantRoleStmt::mutable_grantee_roles() { // @@protoc_insertion_point(field_mutable_list:pg_query.GrantRoleStmt.grantee_roles) return &_impl_.grantee_roles_; } inline const ::pg_query::Node& GrantRoleStmt::_internal_grantee_roles(int index) const { return _impl_.grantee_roles_.Get(index); } inline const ::pg_query::Node& GrantRoleStmt::grantee_roles(int index) const { // @@protoc_insertion_point(field_get:pg_query.GrantRoleStmt.grantee_roles) return _internal_grantee_roles(index); } inline ::pg_query::Node* GrantRoleStmt::_internal_add_grantee_roles() { return _impl_.grantee_roles_.Add(); } inline ::pg_query::Node* GrantRoleStmt::add_grantee_roles() { ::pg_query::Node* _add = _internal_add_grantee_roles(); // @@protoc_insertion_point(field_add:pg_query.GrantRoleStmt.grantee_roles) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& GrantRoleStmt::grantee_roles() const { // @@protoc_insertion_point(field_list:pg_query.GrantRoleStmt.grantee_roles) return _impl_.grantee_roles_; } // bool is_grant = 3 [json_name = "is_grant"]; inline void GrantRoleStmt::clear_is_grant() { _impl_.is_grant_ = false; } inline bool GrantRoleStmt::_internal_is_grant() const { return _impl_.is_grant_; } inline bool GrantRoleStmt::is_grant() const { // @@protoc_insertion_point(field_get:pg_query.GrantRoleStmt.is_grant) return _internal_is_grant(); } inline void GrantRoleStmt::_internal_set_is_grant(bool value) { _impl_.is_grant_ = value; } inline void GrantRoleStmt::set_is_grant(bool value) { _internal_set_is_grant(value); // @@protoc_insertion_point(field_set:pg_query.GrantRoleStmt.is_grant) } // bool admin_opt = 4 [json_name = "admin_opt"]; inline void GrantRoleStmt::clear_admin_opt() { _impl_.admin_opt_ = false; } inline bool GrantRoleStmt::_internal_admin_opt() const { return _impl_.admin_opt_; } inline bool GrantRoleStmt::admin_opt() const { // @@protoc_insertion_point(field_get:pg_query.GrantRoleStmt.admin_opt) return _internal_admin_opt(); } inline void GrantRoleStmt::_internal_set_admin_opt(bool value) { _impl_.admin_opt_ = value; } inline void GrantRoleStmt::set_admin_opt(bool value) { _internal_set_admin_opt(value); // @@protoc_insertion_point(field_set:pg_query.GrantRoleStmt.admin_opt) } // .pg_query.RoleSpec grantor = 5 [json_name = "grantor"]; inline bool GrantRoleStmt::_internal_has_grantor() const { return this != internal_default_instance() && _impl_.grantor_ != nullptr; } inline bool GrantRoleStmt::has_grantor() const { return _internal_has_grantor(); } inline void GrantRoleStmt::clear_grantor() { if (GetArenaForAllocation() == nullptr && _impl_.grantor_ != nullptr) { delete _impl_.grantor_; } _impl_.grantor_ = nullptr; } inline const ::pg_query::RoleSpec& GrantRoleStmt::_internal_grantor() const { const ::pg_query::RoleSpec* p = _impl_.grantor_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RoleSpec_default_instance_); } inline const ::pg_query::RoleSpec& GrantRoleStmt::grantor() const { // @@protoc_insertion_point(field_get:pg_query.GrantRoleStmt.grantor) return _internal_grantor(); } inline void GrantRoleStmt::unsafe_arena_set_allocated_grantor( ::pg_query::RoleSpec* grantor) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.grantor_); } _impl_.grantor_ = grantor; if (grantor) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.GrantRoleStmt.grantor) } inline ::pg_query::RoleSpec* GrantRoleStmt::release_grantor() { ::pg_query::RoleSpec* temp = _impl_.grantor_; _impl_.grantor_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RoleSpec* GrantRoleStmt::unsafe_arena_release_grantor() { // @@protoc_insertion_point(field_release:pg_query.GrantRoleStmt.grantor) ::pg_query::RoleSpec* temp = _impl_.grantor_; _impl_.grantor_ = nullptr; return temp; } inline ::pg_query::RoleSpec* GrantRoleStmt::_internal_mutable_grantor() { if (_impl_.grantor_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArenaForAllocation()); _impl_.grantor_ = p; } return _impl_.grantor_; } inline ::pg_query::RoleSpec* GrantRoleStmt::mutable_grantor() { ::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* grantor) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.grantor_; } if (grantor) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(grantor); if (message_arena != submessage_arena) { grantor = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, grantor, submessage_arena); } } else { } _impl_.grantor_ = grantor; // @@protoc_insertion_point(field_set_allocated:pg_query.GrantRoleStmt.grantor) } // .pg_query.DropBehavior behavior = 6 [json_name = "behavior"]; inline void GrantRoleStmt::clear_behavior() { _impl_.behavior_ = 0; } inline ::pg_query::DropBehavior GrantRoleStmt::_internal_behavior() const { return static_cast< ::pg_query::DropBehavior >(_impl_.behavior_); } inline ::pg_query::DropBehavior GrantRoleStmt::behavior() const { // @@protoc_insertion_point(field_get:pg_query.GrantRoleStmt.behavior) return _internal_behavior(); } inline void GrantRoleStmt::_internal_set_behavior(::pg_query::DropBehavior value) { _impl_.behavior_ = value; } inline void GrantRoleStmt::set_behavior(::pg_query::DropBehavior value) { _internal_set_behavior(value); // @@protoc_insertion_point(field_set:pg_query.GrantRoleStmt.behavior) } // ------------------------------------------------------------------- // AlterDefaultPrivilegesStmt // repeated .pg_query.Node options = 1 [json_name = "options"]; inline int AlterDefaultPrivilegesStmt::_internal_options_size() const { return _impl_.options_.size(); } inline int AlterDefaultPrivilegesStmt::options_size() const { return _internal_options_size(); } inline void AlterDefaultPrivilegesStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* AlterDefaultPrivilegesStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterDefaultPrivilegesStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterDefaultPrivilegesStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterDefaultPrivilegesStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& AlterDefaultPrivilegesStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& AlterDefaultPrivilegesStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterDefaultPrivilegesStmt.options) return _internal_options(index); } inline ::pg_query::Node* AlterDefaultPrivilegesStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* AlterDefaultPrivilegesStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.AlterDefaultPrivilegesStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterDefaultPrivilegesStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.AlterDefaultPrivilegesStmt.options) return _impl_.options_; } // .pg_query.GrantStmt action = 2 [json_name = "action"]; inline bool AlterDefaultPrivilegesStmt::_internal_has_action() const { return this != internal_default_instance() && _impl_.action_ != nullptr; } inline bool AlterDefaultPrivilegesStmt::has_action() const { return _internal_has_action(); } inline void AlterDefaultPrivilegesStmt::clear_action() { if (GetArenaForAllocation() == nullptr && _impl_.action_ != nullptr) { delete _impl_.action_; } _impl_.action_ = nullptr; } inline const ::pg_query::GrantStmt& AlterDefaultPrivilegesStmt::_internal_action() const { const ::pg_query::GrantStmt* p = _impl_.action_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_GrantStmt_default_instance_); } inline const ::pg_query::GrantStmt& AlterDefaultPrivilegesStmt::action() const { // @@protoc_insertion_point(field_get:pg_query.AlterDefaultPrivilegesStmt.action) return _internal_action(); } inline void AlterDefaultPrivilegesStmt::unsafe_arena_set_allocated_action( ::pg_query::GrantStmt* action) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.action_); } _impl_.action_ = action; if (action) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterDefaultPrivilegesStmt.action) } inline ::pg_query::GrantStmt* AlterDefaultPrivilegesStmt::release_action() { ::pg_query::GrantStmt* temp = _impl_.action_; _impl_.action_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::GrantStmt* AlterDefaultPrivilegesStmt::unsafe_arena_release_action() { // @@protoc_insertion_point(field_release:pg_query.AlterDefaultPrivilegesStmt.action) ::pg_query::GrantStmt* temp = _impl_.action_; _impl_.action_ = nullptr; return temp; } inline ::pg_query::GrantStmt* AlterDefaultPrivilegesStmt::_internal_mutable_action() { if (_impl_.action_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::GrantStmt>(GetArenaForAllocation()); _impl_.action_ = p; } return _impl_.action_; } inline ::pg_query::GrantStmt* AlterDefaultPrivilegesStmt::mutable_action() { ::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* action) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.action_; } if (action) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(action); if (message_arena != submessage_arena) { action = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, action, submessage_arena); } } else { } _impl_.action_ = action; // @@protoc_insertion_point(field_set_allocated:pg_query.AlterDefaultPrivilegesStmt.action) } // ------------------------------------------------------------------- // ClosePortalStmt // string portalname = 1 [json_name = "portalname"]; inline void ClosePortalStmt::clear_portalname() { _impl_.portalname_.ClearToEmpty(); } inline const std::string& ClosePortalStmt::portalname() const { // @@protoc_insertion_point(field_get:pg_query.ClosePortalStmt.portalname) return _internal_portalname(); } template inline PROTOBUF_ALWAYS_INLINE void ClosePortalStmt::set_portalname(ArgT0&& arg0, ArgT... args) { _impl_.portalname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.ClosePortalStmt.portalname) } inline std::string* ClosePortalStmt::mutable_portalname() { 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 { return _impl_.portalname_.Get(); } inline void ClosePortalStmt::_internal_set_portalname(const std::string& value) { _impl_.portalname_.Set(value, GetArenaForAllocation()); } inline std::string* ClosePortalStmt::_internal_mutable_portalname() { return _impl_.portalname_.Mutable(GetArenaForAllocation()); } inline std::string* ClosePortalStmt::release_portalname() { // @@protoc_insertion_point(field_release:pg_query.ClosePortalStmt.portalname) return _impl_.portalname_.Release(); } inline void ClosePortalStmt::set_allocated_portalname(std::string* portalname) { if (portalname != nullptr) { } else { } _impl_.portalname_.SetAllocated(portalname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.portalname_.IsDefault()) { _impl_.portalname_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:pg_query.ClosePortalStmt.portalname) } // ------------------------------------------------------------------- // ClusterStmt // .pg_query.RangeVar relation = 1 [json_name = "relation"]; inline bool ClusterStmt::_internal_has_relation() const { return this != internal_default_instance() && _impl_.relation_ != nullptr; } inline bool ClusterStmt::has_relation() const { return _internal_has_relation(); } inline void ClusterStmt::clear_relation() { if (GetArenaForAllocation() == nullptr && _impl_.relation_ != nullptr) { delete _impl_.relation_; } _impl_.relation_ = nullptr; } inline const ::pg_query::RangeVar& ClusterStmt::_internal_relation() const { const ::pg_query::RangeVar* p = _impl_.relation_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& ClusterStmt::relation() const { // @@protoc_insertion_point(field_get:pg_query.ClusterStmt.relation) return _internal_relation(); } inline void ClusterStmt::unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.relation_); } _impl_.relation_ = relation; if (relation) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ClusterStmt.relation) } inline ::pg_query::RangeVar* ClusterStmt::release_relation() { ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* ClusterStmt::unsafe_arena_release_relation() { // @@protoc_insertion_point(field_release:pg_query.ClusterStmt.relation) ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; return temp; } inline ::pg_query::RangeVar* ClusterStmt::_internal_mutable_relation() { if (_impl_.relation_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.relation_ = p; } return _impl_.relation_; } inline ::pg_query::RangeVar* ClusterStmt::mutable_relation() { ::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* relation) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.relation_; } if (relation) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(relation); if (message_arena != submessage_arena) { relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, relation, submessage_arena); } } else { } _impl_.relation_ = relation; // @@protoc_insertion_point(field_set_allocated:pg_query.ClusterStmt.relation) } // string indexname = 2 [json_name = "indexname"]; inline void ClusterStmt::clear_indexname() { _impl_.indexname_.ClearToEmpty(); } inline const std::string& ClusterStmt::indexname() const { // @@protoc_insertion_point(field_get:pg_query.ClusterStmt.indexname) return _internal_indexname(); } template inline PROTOBUF_ALWAYS_INLINE void ClusterStmt::set_indexname(ArgT0&& arg0, ArgT... args) { _impl_.indexname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.ClusterStmt.indexname) } inline std::string* ClusterStmt::mutable_indexname() { 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 { return _impl_.indexname_.Get(); } inline void ClusterStmt::_internal_set_indexname(const std::string& value) { _impl_.indexname_.Set(value, GetArenaForAllocation()); } inline std::string* ClusterStmt::_internal_mutable_indexname() { return _impl_.indexname_.Mutable(GetArenaForAllocation()); } inline std::string* ClusterStmt::release_indexname() { // @@protoc_insertion_point(field_release:pg_query.ClusterStmt.indexname) return _impl_.indexname_.Release(); } inline void ClusterStmt::set_allocated_indexname(std::string* indexname) { if (indexname != nullptr) { } else { } _impl_.indexname_.SetAllocated(indexname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.indexname_.IsDefault()) { _impl_.indexname_.Set("", GetArenaForAllocation()); } #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 _impl_.params_.size(); } inline int ClusterStmt::params_size() const { return _internal_params_size(); } inline void ClusterStmt::clear_params() { _impl_.params_.Clear(); } inline ::pg_query::Node* ClusterStmt::mutable_params(int index) { // @@protoc_insertion_point(field_mutable:pg_query.ClusterStmt.params) return _impl_.params_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* ClusterStmt::mutable_params() { // @@protoc_insertion_point(field_mutable_list:pg_query.ClusterStmt.params) return &_impl_.params_; } inline const ::pg_query::Node& ClusterStmt::_internal_params(int index) const { return _impl_.params_.Get(index); } inline const ::pg_query::Node& ClusterStmt::params(int index) const { // @@protoc_insertion_point(field_get:pg_query.ClusterStmt.params) return _internal_params(index); } inline ::pg_query::Node* ClusterStmt::_internal_add_params() { return _impl_.params_.Add(); } inline ::pg_query::Node* ClusterStmt::add_params() { ::pg_query::Node* _add = _internal_add_params(); // @@protoc_insertion_point(field_add:pg_query.ClusterStmt.params) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& ClusterStmt::params() const { // @@protoc_insertion_point(field_list:pg_query.ClusterStmt.params) return _impl_.params_; } // ------------------------------------------------------------------- // CopyStmt // .pg_query.RangeVar relation = 1 [json_name = "relation"]; inline bool CopyStmt::_internal_has_relation() const { return this != internal_default_instance() && _impl_.relation_ != nullptr; } inline bool CopyStmt::has_relation() const { return _internal_has_relation(); } inline void CopyStmt::clear_relation() { if (GetArenaForAllocation() == nullptr && _impl_.relation_ != nullptr) { delete _impl_.relation_; } _impl_.relation_ = nullptr; } inline const ::pg_query::RangeVar& CopyStmt::_internal_relation() const { const ::pg_query::RangeVar* p = _impl_.relation_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& CopyStmt::relation() const { // @@protoc_insertion_point(field_get:pg_query.CopyStmt.relation) return _internal_relation(); } inline void CopyStmt::unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.relation_); } _impl_.relation_ = relation; if (relation) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CopyStmt.relation) } inline ::pg_query::RangeVar* CopyStmt::release_relation() { ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* CopyStmt::unsafe_arena_release_relation() { // @@protoc_insertion_point(field_release:pg_query.CopyStmt.relation) ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; return temp; } inline ::pg_query::RangeVar* CopyStmt::_internal_mutable_relation() { if (_impl_.relation_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.relation_ = p; } return _impl_.relation_; } inline ::pg_query::RangeVar* CopyStmt::mutable_relation() { ::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* relation) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.relation_; } if (relation) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(relation); if (message_arena != submessage_arena) { relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, relation, submessage_arena); } } else { } _impl_.relation_ = relation; // @@protoc_insertion_point(field_set_allocated:pg_query.CopyStmt.relation) } // .pg_query.Node query = 2 [json_name = "query"]; inline bool CopyStmt::_internal_has_query() const { return this != internal_default_instance() && _impl_.query_ != nullptr; } inline bool CopyStmt::has_query() const { return _internal_has_query(); } inline void CopyStmt::clear_query() { if (GetArenaForAllocation() == nullptr && _impl_.query_ != nullptr) { delete _impl_.query_; } _impl_.query_ = nullptr; } inline const ::pg_query::Node& CopyStmt::_internal_query() const { const ::pg_query::Node* p = _impl_.query_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& CopyStmt::query() const { // @@protoc_insertion_point(field_get:pg_query.CopyStmt.query) return _internal_query(); } inline void CopyStmt::unsafe_arena_set_allocated_query( ::pg_query::Node* query) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.query_); } _impl_.query_ = query; if (query) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CopyStmt.query) } inline ::pg_query::Node* CopyStmt::release_query() { ::pg_query::Node* temp = _impl_.query_; _impl_.query_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* CopyStmt::unsafe_arena_release_query() { // @@protoc_insertion_point(field_release:pg_query.CopyStmt.query) ::pg_query::Node* temp = _impl_.query_; _impl_.query_ = nullptr; return temp; } inline ::pg_query::Node* CopyStmt::_internal_mutable_query() { if (_impl_.query_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.query_ = p; } return _impl_.query_; } inline ::pg_query::Node* CopyStmt::mutable_query() { ::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* query) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.query_; } if (query) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(query); if (message_arena != submessage_arena) { query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, query, submessage_arena); } } else { } _impl_.query_ = query; // @@protoc_insertion_point(field_set_allocated:pg_query.CopyStmt.query) } // repeated .pg_query.Node attlist = 3 [json_name = "attlist"]; inline int CopyStmt::_internal_attlist_size() const { return _impl_.attlist_.size(); } inline int CopyStmt::attlist_size() const { return _internal_attlist_size(); } inline void CopyStmt::clear_attlist() { _impl_.attlist_.Clear(); } inline ::pg_query::Node* CopyStmt::mutable_attlist(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CopyStmt.attlist) return _impl_.attlist_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CopyStmt::mutable_attlist() { // @@protoc_insertion_point(field_mutable_list:pg_query.CopyStmt.attlist) return &_impl_.attlist_; } inline const ::pg_query::Node& CopyStmt::_internal_attlist(int index) const { return _impl_.attlist_.Get(index); } inline const ::pg_query::Node& CopyStmt::attlist(int index) const { // @@protoc_insertion_point(field_get:pg_query.CopyStmt.attlist) return _internal_attlist(index); } inline ::pg_query::Node* CopyStmt::_internal_add_attlist() { return _impl_.attlist_.Add(); } inline ::pg_query::Node* CopyStmt::add_attlist() { ::pg_query::Node* _add = _internal_add_attlist(); // @@protoc_insertion_point(field_add:pg_query.CopyStmt.attlist) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CopyStmt::attlist() const { // @@protoc_insertion_point(field_list:pg_query.CopyStmt.attlist) return _impl_.attlist_; } // bool is_from = 4 [json_name = "is_from"]; inline void CopyStmt::clear_is_from() { _impl_.is_from_ = false; } inline bool CopyStmt::_internal_is_from() const { return _impl_.is_from_; } inline bool CopyStmt::is_from() const { // @@protoc_insertion_point(field_get:pg_query.CopyStmt.is_from) return _internal_is_from(); } inline void CopyStmt::_internal_set_is_from(bool value) { _impl_.is_from_ = value; } inline void CopyStmt::set_is_from(bool value) { _internal_set_is_from(value); // @@protoc_insertion_point(field_set:pg_query.CopyStmt.is_from) } // bool is_program = 5 [json_name = "is_program"]; inline void CopyStmt::clear_is_program() { _impl_.is_program_ = false; } inline bool CopyStmt::_internal_is_program() const { return _impl_.is_program_; } inline bool CopyStmt::is_program() const { // @@protoc_insertion_point(field_get:pg_query.CopyStmt.is_program) return _internal_is_program(); } inline void CopyStmt::_internal_set_is_program(bool value) { _impl_.is_program_ = value; } inline void CopyStmt::set_is_program(bool value) { _internal_set_is_program(value); // @@protoc_insertion_point(field_set:pg_query.CopyStmt.is_program) } // string filename = 6 [json_name = "filename"]; inline void CopyStmt::clear_filename() { _impl_.filename_.ClearToEmpty(); } inline const std::string& CopyStmt::filename() const { // @@protoc_insertion_point(field_get:pg_query.CopyStmt.filename) return _internal_filename(); } template inline PROTOBUF_ALWAYS_INLINE void CopyStmt::set_filename(ArgT0&& arg0, ArgT... args) { _impl_.filename_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CopyStmt.filename) } inline std::string* CopyStmt::mutable_filename() { 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 { return _impl_.filename_.Get(); } inline void CopyStmt::_internal_set_filename(const std::string& value) { _impl_.filename_.Set(value, GetArenaForAllocation()); } inline std::string* CopyStmt::_internal_mutable_filename() { return _impl_.filename_.Mutable(GetArenaForAllocation()); } inline std::string* CopyStmt::release_filename() { // @@protoc_insertion_point(field_release:pg_query.CopyStmt.filename) return _impl_.filename_.Release(); } inline void CopyStmt::set_allocated_filename(std::string* filename) { if (filename != nullptr) { } else { } _impl_.filename_.SetAllocated(filename, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.filename_.IsDefault()) { _impl_.filename_.Set("", GetArenaForAllocation()); } #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 _impl_.options_.size(); } inline int CopyStmt::options_size() const { return _internal_options_size(); } inline void CopyStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* CopyStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CopyStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CopyStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.CopyStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& CopyStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& CopyStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.CopyStmt.options) return _internal_options(index); } inline ::pg_query::Node* CopyStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* CopyStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.CopyStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CopyStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.CopyStmt.options) return _impl_.options_; } // .pg_query.Node where_clause = 8 [json_name = "whereClause"]; inline bool CopyStmt::_internal_has_where_clause() const { return this != internal_default_instance() && _impl_.where_clause_ != nullptr; } inline bool CopyStmt::has_where_clause() const { return _internal_has_where_clause(); } inline void CopyStmt::clear_where_clause() { if (GetArenaForAllocation() == nullptr && _impl_.where_clause_ != nullptr) { delete _impl_.where_clause_; } _impl_.where_clause_ = nullptr; } inline const ::pg_query::Node& CopyStmt::_internal_where_clause() const { const ::pg_query::Node* p = _impl_.where_clause_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& CopyStmt::where_clause() const { // @@protoc_insertion_point(field_get:pg_query.CopyStmt.where_clause) return _internal_where_clause(); } inline void CopyStmt::unsafe_arena_set_allocated_where_clause( ::pg_query::Node* where_clause) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.where_clause_); } _impl_.where_clause_ = where_clause; if (where_clause) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CopyStmt.where_clause) } inline ::pg_query::Node* CopyStmt::release_where_clause() { ::pg_query::Node* temp = _impl_.where_clause_; _impl_.where_clause_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* CopyStmt::unsafe_arena_release_where_clause() { // @@protoc_insertion_point(field_release:pg_query.CopyStmt.where_clause) ::pg_query::Node* temp = _impl_.where_clause_; _impl_.where_clause_ = nullptr; return temp; } inline ::pg_query::Node* CopyStmt::_internal_mutable_where_clause() { if (_impl_.where_clause_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.where_clause_ = p; } return _impl_.where_clause_; } inline ::pg_query::Node* CopyStmt::mutable_where_clause() { ::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* where_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.where_clause_; } if (where_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(where_clause); if (message_arena != submessage_arena) { where_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, where_clause, submessage_arena); } } else { } _impl_.where_clause_ = where_clause; // @@protoc_insertion_point(field_set_allocated:pg_query.CopyStmt.where_clause) } // ------------------------------------------------------------------- // CreateStmt // .pg_query.RangeVar relation = 1 [json_name = "relation"]; inline bool CreateStmt::_internal_has_relation() const { return this != internal_default_instance() && _impl_.relation_ != nullptr; } inline bool CreateStmt::has_relation() const { return _internal_has_relation(); } inline void CreateStmt::clear_relation() { if (GetArenaForAllocation() == nullptr && _impl_.relation_ != nullptr) { delete _impl_.relation_; } _impl_.relation_ = nullptr; } inline const ::pg_query::RangeVar& CreateStmt::_internal_relation() const { const ::pg_query::RangeVar* p = _impl_.relation_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& CreateStmt::relation() const { // @@protoc_insertion_point(field_get:pg_query.CreateStmt.relation) return _internal_relation(); } inline void CreateStmt::unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.relation_); } _impl_.relation_ = relation; if (relation) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateStmt.relation) } inline ::pg_query::RangeVar* CreateStmt::release_relation() { ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* CreateStmt::unsafe_arena_release_relation() { // @@protoc_insertion_point(field_release:pg_query.CreateStmt.relation) ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; return temp; } inline ::pg_query::RangeVar* CreateStmt::_internal_mutable_relation() { if (_impl_.relation_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.relation_ = p; } return _impl_.relation_; } inline ::pg_query::RangeVar* CreateStmt::mutable_relation() { ::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* relation) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.relation_; } if (relation) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(relation); if (message_arena != submessage_arena) { relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, relation, submessage_arena); } } else { } _impl_.relation_ = relation; // @@protoc_insertion_point(field_set_allocated:pg_query.CreateStmt.relation) } // repeated .pg_query.Node table_elts = 2 [json_name = "tableElts"]; inline int CreateStmt::_internal_table_elts_size() const { return _impl_.table_elts_.size(); } inline int CreateStmt::table_elts_size() const { return _internal_table_elts_size(); } inline void CreateStmt::clear_table_elts() { _impl_.table_elts_.Clear(); } inline ::pg_query::Node* CreateStmt::mutable_table_elts(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateStmt.table_elts) return _impl_.table_elts_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateStmt::mutable_table_elts() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateStmt.table_elts) return &_impl_.table_elts_; } inline const ::pg_query::Node& CreateStmt::_internal_table_elts(int index) const { return _impl_.table_elts_.Get(index); } inline const ::pg_query::Node& CreateStmt::table_elts(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateStmt.table_elts) return _internal_table_elts(index); } inline ::pg_query::Node* CreateStmt::_internal_add_table_elts() { return _impl_.table_elts_.Add(); } inline ::pg_query::Node* CreateStmt::add_table_elts() { ::pg_query::Node* _add = _internal_add_table_elts(); // @@protoc_insertion_point(field_add:pg_query.CreateStmt.table_elts) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateStmt::table_elts() const { // @@protoc_insertion_point(field_list:pg_query.CreateStmt.table_elts) return _impl_.table_elts_; } // repeated .pg_query.Node inh_relations = 3 [json_name = "inhRelations"]; inline int CreateStmt::_internal_inh_relations_size() const { return _impl_.inh_relations_.size(); } inline int CreateStmt::inh_relations_size() const { return _internal_inh_relations_size(); } inline void CreateStmt::clear_inh_relations() { _impl_.inh_relations_.Clear(); } inline ::pg_query::Node* CreateStmt::mutable_inh_relations(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateStmt.inh_relations) return _impl_.inh_relations_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateStmt::mutable_inh_relations() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateStmt.inh_relations) return &_impl_.inh_relations_; } inline const ::pg_query::Node& CreateStmt::_internal_inh_relations(int index) const { return _impl_.inh_relations_.Get(index); } inline const ::pg_query::Node& CreateStmt::inh_relations(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateStmt.inh_relations) return _internal_inh_relations(index); } inline ::pg_query::Node* CreateStmt::_internal_add_inh_relations() { return _impl_.inh_relations_.Add(); } inline ::pg_query::Node* CreateStmt::add_inh_relations() { ::pg_query::Node* _add = _internal_add_inh_relations(); // @@protoc_insertion_point(field_add:pg_query.CreateStmt.inh_relations) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateStmt::inh_relations() const { // @@protoc_insertion_point(field_list:pg_query.CreateStmt.inh_relations) return _impl_.inh_relations_; } // .pg_query.PartitionBoundSpec partbound = 4 [json_name = "partbound"]; inline bool CreateStmt::_internal_has_partbound() const { return this != internal_default_instance() && _impl_.partbound_ != nullptr; } inline bool CreateStmt::has_partbound() const { return _internal_has_partbound(); } inline void CreateStmt::clear_partbound() { if (GetArenaForAllocation() == nullptr && _impl_.partbound_ != nullptr) { delete _impl_.partbound_; } _impl_.partbound_ = nullptr; } inline const ::pg_query::PartitionBoundSpec& CreateStmt::_internal_partbound() const { const ::pg_query::PartitionBoundSpec* p = _impl_.partbound_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_PartitionBoundSpec_default_instance_); } inline const ::pg_query::PartitionBoundSpec& CreateStmt::partbound() const { // @@protoc_insertion_point(field_get:pg_query.CreateStmt.partbound) return _internal_partbound(); } inline void CreateStmt::unsafe_arena_set_allocated_partbound( ::pg_query::PartitionBoundSpec* partbound) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.partbound_); } _impl_.partbound_ = partbound; if (partbound) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateStmt.partbound) } inline ::pg_query::PartitionBoundSpec* CreateStmt::release_partbound() { ::pg_query::PartitionBoundSpec* temp = _impl_.partbound_; _impl_.partbound_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::PartitionBoundSpec* CreateStmt::unsafe_arena_release_partbound() { // @@protoc_insertion_point(field_release:pg_query.CreateStmt.partbound) ::pg_query::PartitionBoundSpec* temp = _impl_.partbound_; _impl_.partbound_ = nullptr; return temp; } inline ::pg_query::PartitionBoundSpec* CreateStmt::_internal_mutable_partbound() { if (_impl_.partbound_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::PartitionBoundSpec>(GetArenaForAllocation()); _impl_.partbound_ = p; } return _impl_.partbound_; } inline ::pg_query::PartitionBoundSpec* CreateStmt::mutable_partbound() { ::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* partbound) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.partbound_; } if (partbound) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(partbound); if (message_arena != submessage_arena) { partbound = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, partbound, submessage_arena); } } else { } _impl_.partbound_ = partbound; // @@protoc_insertion_point(field_set_allocated:pg_query.CreateStmt.partbound) } // .pg_query.PartitionSpec partspec = 5 [json_name = "partspec"]; inline bool CreateStmt::_internal_has_partspec() const { return this != internal_default_instance() && _impl_.partspec_ != nullptr; } inline bool CreateStmt::has_partspec() const { return _internal_has_partspec(); } inline void CreateStmt::clear_partspec() { if (GetArenaForAllocation() == nullptr && _impl_.partspec_ != nullptr) { delete _impl_.partspec_; } _impl_.partspec_ = nullptr; } inline const ::pg_query::PartitionSpec& CreateStmt::_internal_partspec() const { const ::pg_query::PartitionSpec* p = _impl_.partspec_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_PartitionSpec_default_instance_); } inline const ::pg_query::PartitionSpec& CreateStmt::partspec() const { // @@protoc_insertion_point(field_get:pg_query.CreateStmt.partspec) return _internal_partspec(); } inline void CreateStmt::unsafe_arena_set_allocated_partspec( ::pg_query::PartitionSpec* partspec) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.partspec_); } _impl_.partspec_ = partspec; if (partspec) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateStmt.partspec) } inline ::pg_query::PartitionSpec* CreateStmt::release_partspec() { ::pg_query::PartitionSpec* temp = _impl_.partspec_; _impl_.partspec_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::PartitionSpec* CreateStmt::unsafe_arena_release_partspec() { // @@protoc_insertion_point(field_release:pg_query.CreateStmt.partspec) ::pg_query::PartitionSpec* temp = _impl_.partspec_; _impl_.partspec_ = nullptr; return temp; } inline ::pg_query::PartitionSpec* CreateStmt::_internal_mutable_partspec() { if (_impl_.partspec_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::PartitionSpec>(GetArenaForAllocation()); _impl_.partspec_ = p; } return _impl_.partspec_; } inline ::pg_query::PartitionSpec* CreateStmt::mutable_partspec() { ::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* partspec) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.partspec_; } if (partspec) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(partspec); if (message_arena != submessage_arena) { partspec = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, partspec, submessage_arena); } } else { } _impl_.partspec_ = partspec; // @@protoc_insertion_point(field_set_allocated:pg_query.CreateStmt.partspec) } // .pg_query.TypeName of_typename = 6 [json_name = "ofTypename"]; inline bool CreateStmt::_internal_has_of_typename() const { return this != internal_default_instance() && _impl_.of_typename_ != nullptr; } inline bool CreateStmt::has_of_typename() const { return _internal_has_of_typename(); } inline void CreateStmt::clear_of_typename() { if (GetArenaForAllocation() == nullptr && _impl_.of_typename_ != nullptr) { delete _impl_.of_typename_; } _impl_.of_typename_ = nullptr; } inline const ::pg_query::TypeName& CreateStmt::_internal_of_typename() const { const ::pg_query::TypeName* p = _impl_.of_typename_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_TypeName_default_instance_); } inline const ::pg_query::TypeName& CreateStmt::of_typename() const { // @@protoc_insertion_point(field_get:pg_query.CreateStmt.of_typename) return _internal_of_typename(); } inline void CreateStmt::unsafe_arena_set_allocated_of_typename( ::pg_query::TypeName* of_typename) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.of_typename_); } _impl_.of_typename_ = of_typename; if (of_typename) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateStmt.of_typename) } inline ::pg_query::TypeName* CreateStmt::release_of_typename() { ::pg_query::TypeName* temp = _impl_.of_typename_; _impl_.of_typename_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::TypeName* CreateStmt::unsafe_arena_release_of_typename() { // @@protoc_insertion_point(field_release:pg_query.CreateStmt.of_typename) ::pg_query::TypeName* temp = _impl_.of_typename_; _impl_.of_typename_ = nullptr; return temp; } inline ::pg_query::TypeName* CreateStmt::_internal_mutable_of_typename() { if (_impl_.of_typename_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArenaForAllocation()); _impl_.of_typename_ = p; } return _impl_.of_typename_; } inline ::pg_query::TypeName* CreateStmt::mutable_of_typename() { ::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* of_typename) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.of_typename_; } if (of_typename) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(of_typename); if (message_arena != submessage_arena) { of_typename = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, of_typename, submessage_arena); } } else { } _impl_.of_typename_ = of_typename; // @@protoc_insertion_point(field_set_allocated:pg_query.CreateStmt.of_typename) } // repeated .pg_query.Node constraints = 7 [json_name = "constraints"]; inline int CreateStmt::_internal_constraints_size() const { return _impl_.constraints_.size(); } inline int CreateStmt::constraints_size() const { return _internal_constraints_size(); } inline void CreateStmt::clear_constraints() { _impl_.constraints_.Clear(); } inline ::pg_query::Node* CreateStmt::mutable_constraints(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateStmt.constraints) return _impl_.constraints_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateStmt::mutable_constraints() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateStmt.constraints) return &_impl_.constraints_; } inline const ::pg_query::Node& CreateStmt::_internal_constraints(int index) const { return _impl_.constraints_.Get(index); } inline const ::pg_query::Node& CreateStmt::constraints(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateStmt.constraints) return _internal_constraints(index); } inline ::pg_query::Node* CreateStmt::_internal_add_constraints() { return _impl_.constraints_.Add(); } inline ::pg_query::Node* CreateStmt::add_constraints() { ::pg_query::Node* _add = _internal_add_constraints(); // @@protoc_insertion_point(field_add:pg_query.CreateStmt.constraints) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateStmt::constraints() const { // @@protoc_insertion_point(field_list:pg_query.CreateStmt.constraints) return _impl_.constraints_; } // repeated .pg_query.Node options = 8 [json_name = "options"]; inline int CreateStmt::_internal_options_size() const { return _impl_.options_.size(); } inline int CreateStmt::options_size() const { return _internal_options_size(); } inline void CreateStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* CreateStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& CreateStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& CreateStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateStmt.options) return _internal_options(index); } inline ::pg_query::Node* CreateStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* CreateStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.CreateStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.CreateStmt.options) return _impl_.options_; } // .pg_query.OnCommitAction oncommit = 9 [json_name = "oncommit"]; inline void CreateStmt::clear_oncommit() { _impl_.oncommit_ = 0; } inline ::pg_query::OnCommitAction CreateStmt::_internal_oncommit() const { return static_cast< ::pg_query::OnCommitAction >(_impl_.oncommit_); } inline ::pg_query::OnCommitAction CreateStmt::oncommit() const { // @@protoc_insertion_point(field_get:pg_query.CreateStmt.oncommit) return _internal_oncommit(); } inline void CreateStmt::_internal_set_oncommit(::pg_query::OnCommitAction value) { _impl_.oncommit_ = value; } inline void CreateStmt::set_oncommit(::pg_query::OnCommitAction value) { _internal_set_oncommit(value); // @@protoc_insertion_point(field_set:pg_query.CreateStmt.oncommit) } // string tablespacename = 10 [json_name = "tablespacename"]; inline void CreateStmt::clear_tablespacename() { _impl_.tablespacename_.ClearToEmpty(); } inline const std::string& CreateStmt::tablespacename() const { // @@protoc_insertion_point(field_get:pg_query.CreateStmt.tablespacename) return _internal_tablespacename(); } template inline PROTOBUF_ALWAYS_INLINE void CreateStmt::set_tablespacename(ArgT0&& arg0, ArgT... args) { _impl_.tablespacename_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreateStmt.tablespacename) } inline std::string* CreateStmt::mutable_tablespacename() { 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 { return _impl_.tablespacename_.Get(); } inline void CreateStmt::_internal_set_tablespacename(const std::string& value) { _impl_.tablespacename_.Set(value, GetArenaForAllocation()); } inline std::string* CreateStmt::_internal_mutable_tablespacename() { return _impl_.tablespacename_.Mutable(GetArenaForAllocation()); } inline std::string* CreateStmt::release_tablespacename() { // @@protoc_insertion_point(field_release:pg_query.CreateStmt.tablespacename) return _impl_.tablespacename_.Release(); } inline void CreateStmt::set_allocated_tablespacename(std::string* tablespacename) { if (tablespacename != nullptr) { } else { } _impl_.tablespacename_.SetAllocated(tablespacename, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.tablespacename_.IsDefault()) { _impl_.tablespacename_.Set("", GetArenaForAllocation()); } #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() { _impl_.access_method_.ClearToEmpty(); } inline const std::string& CreateStmt::access_method() const { // @@protoc_insertion_point(field_get:pg_query.CreateStmt.access_method) return _internal_access_method(); } template inline PROTOBUF_ALWAYS_INLINE void CreateStmt::set_access_method(ArgT0&& arg0, ArgT... args) { _impl_.access_method_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreateStmt.access_method) } inline std::string* CreateStmt::mutable_access_method() { 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 { return _impl_.access_method_.Get(); } inline void CreateStmt::_internal_set_access_method(const std::string& value) { _impl_.access_method_.Set(value, GetArenaForAllocation()); } inline std::string* CreateStmt::_internal_mutable_access_method() { return _impl_.access_method_.Mutable(GetArenaForAllocation()); } inline std::string* CreateStmt::release_access_method() { // @@protoc_insertion_point(field_release:pg_query.CreateStmt.access_method) return _impl_.access_method_.Release(); } inline void CreateStmt::set_allocated_access_method(std::string* access_method) { if (access_method != nullptr) { } else { } _impl_.access_method_.SetAllocated(access_method, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.access_method_.IsDefault()) { _impl_.access_method_.Set("", GetArenaForAllocation()); } #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() { _impl_.if_not_exists_ = false; } inline bool CreateStmt::_internal_if_not_exists() const { return _impl_.if_not_exists_; } inline bool CreateStmt::if_not_exists() const { // @@protoc_insertion_point(field_get:pg_query.CreateStmt.if_not_exists) return _internal_if_not_exists(); } inline void CreateStmt::_internal_set_if_not_exists(bool value) { _impl_.if_not_exists_ = value; } inline void CreateStmt::set_if_not_exists(bool value) { _internal_set_if_not_exists(value); // @@protoc_insertion_point(field_set:pg_query.CreateStmt.if_not_exists) } // ------------------------------------------------------------------- // DefineStmt // .pg_query.ObjectType kind = 1 [json_name = "kind"]; inline void DefineStmt::clear_kind() { _impl_.kind_ = 0; } inline ::pg_query::ObjectType DefineStmt::_internal_kind() const { return static_cast< ::pg_query::ObjectType >(_impl_.kind_); } inline ::pg_query::ObjectType DefineStmt::kind() const { // @@protoc_insertion_point(field_get:pg_query.DefineStmt.kind) return _internal_kind(); } inline void DefineStmt::_internal_set_kind(::pg_query::ObjectType value) { _impl_.kind_ = value; } inline void DefineStmt::set_kind(::pg_query::ObjectType value) { _internal_set_kind(value); // @@protoc_insertion_point(field_set:pg_query.DefineStmt.kind) } // bool oldstyle = 2 [json_name = "oldstyle"]; inline void DefineStmt::clear_oldstyle() { _impl_.oldstyle_ = false; } inline bool DefineStmt::_internal_oldstyle() const { return _impl_.oldstyle_; } inline bool DefineStmt::oldstyle() const { // @@protoc_insertion_point(field_get:pg_query.DefineStmt.oldstyle) return _internal_oldstyle(); } inline void DefineStmt::_internal_set_oldstyle(bool value) { _impl_.oldstyle_ = value; } inline void DefineStmt::set_oldstyle(bool value) { _internal_set_oldstyle(value); // @@protoc_insertion_point(field_set:pg_query.DefineStmt.oldstyle) } // repeated .pg_query.Node defnames = 3 [json_name = "defnames"]; inline int DefineStmt::_internal_defnames_size() const { return _impl_.defnames_.size(); } inline int DefineStmt::defnames_size() const { return _internal_defnames_size(); } inline void DefineStmt::clear_defnames() { _impl_.defnames_.Clear(); } inline ::pg_query::Node* DefineStmt::mutable_defnames(int index) { // @@protoc_insertion_point(field_mutable:pg_query.DefineStmt.defnames) return _impl_.defnames_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* DefineStmt::mutable_defnames() { // @@protoc_insertion_point(field_mutable_list:pg_query.DefineStmt.defnames) return &_impl_.defnames_; } inline const ::pg_query::Node& DefineStmt::_internal_defnames(int index) const { return _impl_.defnames_.Get(index); } inline const ::pg_query::Node& DefineStmt::defnames(int index) const { // @@protoc_insertion_point(field_get:pg_query.DefineStmt.defnames) return _internal_defnames(index); } inline ::pg_query::Node* DefineStmt::_internal_add_defnames() { return _impl_.defnames_.Add(); } inline ::pg_query::Node* DefineStmt::add_defnames() { ::pg_query::Node* _add = _internal_add_defnames(); // @@protoc_insertion_point(field_add:pg_query.DefineStmt.defnames) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& DefineStmt::defnames() const { // @@protoc_insertion_point(field_list:pg_query.DefineStmt.defnames) return _impl_.defnames_; } // repeated .pg_query.Node args = 4 [json_name = "args"]; inline int DefineStmt::_internal_args_size() const { return _impl_.args_.size(); } inline int DefineStmt::args_size() const { return _internal_args_size(); } inline void DefineStmt::clear_args() { _impl_.args_.Clear(); } inline ::pg_query::Node* DefineStmt::mutable_args(int index) { // @@protoc_insertion_point(field_mutable:pg_query.DefineStmt.args) return _impl_.args_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* DefineStmt::mutable_args() { // @@protoc_insertion_point(field_mutable_list:pg_query.DefineStmt.args) return &_impl_.args_; } inline const ::pg_query::Node& DefineStmt::_internal_args(int index) const { return _impl_.args_.Get(index); } inline const ::pg_query::Node& DefineStmt::args(int index) const { // @@protoc_insertion_point(field_get:pg_query.DefineStmt.args) return _internal_args(index); } inline ::pg_query::Node* DefineStmt::_internal_add_args() { return _impl_.args_.Add(); } inline ::pg_query::Node* DefineStmt::add_args() { ::pg_query::Node* _add = _internal_add_args(); // @@protoc_insertion_point(field_add:pg_query.DefineStmt.args) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& DefineStmt::args() const { // @@protoc_insertion_point(field_list:pg_query.DefineStmt.args) return _impl_.args_; } // repeated .pg_query.Node definition = 5 [json_name = "definition"]; inline int DefineStmt::_internal_definition_size() const { return _impl_.definition_.size(); } inline int DefineStmt::definition_size() const { return _internal_definition_size(); } inline void DefineStmt::clear_definition() { _impl_.definition_.Clear(); } inline ::pg_query::Node* DefineStmt::mutable_definition(int index) { // @@protoc_insertion_point(field_mutable:pg_query.DefineStmt.definition) return _impl_.definition_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* DefineStmt::mutable_definition() { // @@protoc_insertion_point(field_mutable_list:pg_query.DefineStmt.definition) return &_impl_.definition_; } inline const ::pg_query::Node& DefineStmt::_internal_definition(int index) const { return _impl_.definition_.Get(index); } inline const ::pg_query::Node& DefineStmt::definition(int index) const { // @@protoc_insertion_point(field_get:pg_query.DefineStmt.definition) return _internal_definition(index); } inline ::pg_query::Node* DefineStmt::_internal_add_definition() { return _impl_.definition_.Add(); } inline ::pg_query::Node* DefineStmt::add_definition() { ::pg_query::Node* _add = _internal_add_definition(); // @@protoc_insertion_point(field_add:pg_query.DefineStmt.definition) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& DefineStmt::definition() const { // @@protoc_insertion_point(field_list:pg_query.DefineStmt.definition) return _impl_.definition_; } // bool if_not_exists = 6 [json_name = "if_not_exists"]; inline void DefineStmt::clear_if_not_exists() { _impl_.if_not_exists_ = false; } inline bool DefineStmt::_internal_if_not_exists() const { return _impl_.if_not_exists_; } inline bool DefineStmt::if_not_exists() const { // @@protoc_insertion_point(field_get:pg_query.DefineStmt.if_not_exists) return _internal_if_not_exists(); } inline void DefineStmt::_internal_set_if_not_exists(bool value) { _impl_.if_not_exists_ = value; } inline void DefineStmt::set_if_not_exists(bool value) { _internal_set_if_not_exists(value); // @@protoc_insertion_point(field_set:pg_query.DefineStmt.if_not_exists) } // bool replace = 7 [json_name = "replace"]; inline void DefineStmt::clear_replace() { _impl_.replace_ = false; } inline bool DefineStmt::_internal_replace() const { return _impl_.replace_; } inline bool DefineStmt::replace() const { // @@protoc_insertion_point(field_get:pg_query.DefineStmt.replace) return _internal_replace(); } inline void DefineStmt::_internal_set_replace(bool value) { _impl_.replace_ = value; } inline void DefineStmt::set_replace(bool value) { _internal_set_replace(value); // @@protoc_insertion_point(field_set:pg_query.DefineStmt.replace) } // ------------------------------------------------------------------- // DropStmt // repeated .pg_query.Node objects = 1 [json_name = "objects"]; inline int DropStmt::_internal_objects_size() const { return _impl_.objects_.size(); } inline int DropStmt::objects_size() const { return _internal_objects_size(); } inline void DropStmt::clear_objects() { _impl_.objects_.Clear(); } inline ::pg_query::Node* DropStmt::mutable_objects(int index) { // @@protoc_insertion_point(field_mutable:pg_query.DropStmt.objects) return _impl_.objects_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* DropStmt::mutable_objects() { // @@protoc_insertion_point(field_mutable_list:pg_query.DropStmt.objects) return &_impl_.objects_; } inline const ::pg_query::Node& DropStmt::_internal_objects(int index) const { return _impl_.objects_.Get(index); } inline const ::pg_query::Node& DropStmt::objects(int index) const { // @@protoc_insertion_point(field_get:pg_query.DropStmt.objects) return _internal_objects(index); } inline ::pg_query::Node* DropStmt::_internal_add_objects() { return _impl_.objects_.Add(); } inline ::pg_query::Node* DropStmt::add_objects() { ::pg_query::Node* _add = _internal_add_objects(); // @@protoc_insertion_point(field_add:pg_query.DropStmt.objects) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& DropStmt::objects() const { // @@protoc_insertion_point(field_list:pg_query.DropStmt.objects) return _impl_.objects_; } // .pg_query.ObjectType remove_type = 2 [json_name = "removeType"]; inline void DropStmt::clear_remove_type() { _impl_.remove_type_ = 0; } inline ::pg_query::ObjectType DropStmt::_internal_remove_type() const { return static_cast< ::pg_query::ObjectType >(_impl_.remove_type_); } inline ::pg_query::ObjectType DropStmt::remove_type() const { // @@protoc_insertion_point(field_get:pg_query.DropStmt.remove_type) return _internal_remove_type(); } inline void DropStmt::_internal_set_remove_type(::pg_query::ObjectType value) { _impl_.remove_type_ = value; } inline void DropStmt::set_remove_type(::pg_query::ObjectType value) { _internal_set_remove_type(value); // @@protoc_insertion_point(field_set:pg_query.DropStmt.remove_type) } // .pg_query.DropBehavior behavior = 3 [json_name = "behavior"]; inline void DropStmt::clear_behavior() { _impl_.behavior_ = 0; } inline ::pg_query::DropBehavior DropStmt::_internal_behavior() const { return static_cast< ::pg_query::DropBehavior >(_impl_.behavior_); } inline ::pg_query::DropBehavior DropStmt::behavior() const { // @@protoc_insertion_point(field_get:pg_query.DropStmt.behavior) return _internal_behavior(); } inline void DropStmt::_internal_set_behavior(::pg_query::DropBehavior value) { _impl_.behavior_ = value; } inline void DropStmt::set_behavior(::pg_query::DropBehavior value) { _internal_set_behavior(value); // @@protoc_insertion_point(field_set:pg_query.DropStmt.behavior) } // bool missing_ok = 4 [json_name = "missing_ok"]; inline void DropStmt::clear_missing_ok() { _impl_.missing_ok_ = false; } inline bool DropStmt::_internal_missing_ok() const { return _impl_.missing_ok_; } inline bool DropStmt::missing_ok() const { // @@protoc_insertion_point(field_get:pg_query.DropStmt.missing_ok) return _internal_missing_ok(); } inline void DropStmt::_internal_set_missing_ok(bool value) { _impl_.missing_ok_ = value; } inline void DropStmt::set_missing_ok(bool value) { _internal_set_missing_ok(value); // @@protoc_insertion_point(field_set:pg_query.DropStmt.missing_ok) } // bool concurrent = 5 [json_name = "concurrent"]; inline void DropStmt::clear_concurrent() { _impl_.concurrent_ = false; } inline bool DropStmt::_internal_concurrent() const { return _impl_.concurrent_; } inline bool DropStmt::concurrent() const { // @@protoc_insertion_point(field_get:pg_query.DropStmt.concurrent) return _internal_concurrent(); } inline void DropStmt::_internal_set_concurrent(bool value) { _impl_.concurrent_ = value; } inline void DropStmt::set_concurrent(bool value) { _internal_set_concurrent(value); // @@protoc_insertion_point(field_set:pg_query.DropStmt.concurrent) } // ------------------------------------------------------------------- // TruncateStmt // repeated .pg_query.Node relations = 1 [json_name = "relations"]; inline int TruncateStmt::_internal_relations_size() const { return _impl_.relations_.size(); } inline int TruncateStmt::relations_size() const { return _internal_relations_size(); } inline void TruncateStmt::clear_relations() { _impl_.relations_.Clear(); } inline ::pg_query::Node* TruncateStmt::mutable_relations(int index) { // @@protoc_insertion_point(field_mutable:pg_query.TruncateStmt.relations) return _impl_.relations_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* TruncateStmt::mutable_relations() { // @@protoc_insertion_point(field_mutable_list:pg_query.TruncateStmt.relations) return &_impl_.relations_; } inline const ::pg_query::Node& TruncateStmt::_internal_relations(int index) const { return _impl_.relations_.Get(index); } inline const ::pg_query::Node& TruncateStmt::relations(int index) const { // @@protoc_insertion_point(field_get:pg_query.TruncateStmt.relations) return _internal_relations(index); } inline ::pg_query::Node* TruncateStmt::_internal_add_relations() { return _impl_.relations_.Add(); } inline ::pg_query::Node* TruncateStmt::add_relations() { ::pg_query::Node* _add = _internal_add_relations(); // @@protoc_insertion_point(field_add:pg_query.TruncateStmt.relations) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& TruncateStmt::relations() const { // @@protoc_insertion_point(field_list:pg_query.TruncateStmt.relations) return _impl_.relations_; } // bool restart_seqs = 2 [json_name = "restart_seqs"]; inline void TruncateStmt::clear_restart_seqs() { _impl_.restart_seqs_ = false; } inline bool TruncateStmt::_internal_restart_seqs() const { return _impl_.restart_seqs_; } inline bool TruncateStmt::restart_seqs() const { // @@protoc_insertion_point(field_get:pg_query.TruncateStmt.restart_seqs) return _internal_restart_seqs(); } inline void TruncateStmt::_internal_set_restart_seqs(bool value) { _impl_.restart_seqs_ = value; } inline void TruncateStmt::set_restart_seqs(bool value) { _internal_set_restart_seqs(value); // @@protoc_insertion_point(field_set:pg_query.TruncateStmt.restart_seqs) } // .pg_query.DropBehavior behavior = 3 [json_name = "behavior"]; inline void TruncateStmt::clear_behavior() { _impl_.behavior_ = 0; } inline ::pg_query::DropBehavior TruncateStmt::_internal_behavior() const { return static_cast< ::pg_query::DropBehavior >(_impl_.behavior_); } inline ::pg_query::DropBehavior TruncateStmt::behavior() const { // @@protoc_insertion_point(field_get:pg_query.TruncateStmt.behavior) return _internal_behavior(); } inline void TruncateStmt::_internal_set_behavior(::pg_query::DropBehavior value) { _impl_.behavior_ = value; } inline void TruncateStmt::set_behavior(::pg_query::DropBehavior value) { _internal_set_behavior(value); // @@protoc_insertion_point(field_set:pg_query.TruncateStmt.behavior) } // ------------------------------------------------------------------- // CommentStmt // .pg_query.ObjectType objtype = 1 [json_name = "objtype"]; inline void CommentStmt::clear_objtype() { _impl_.objtype_ = 0; } inline ::pg_query::ObjectType CommentStmt::_internal_objtype() const { return static_cast< ::pg_query::ObjectType >(_impl_.objtype_); } inline ::pg_query::ObjectType CommentStmt::objtype() const { // @@protoc_insertion_point(field_get:pg_query.CommentStmt.objtype) return _internal_objtype(); } inline void CommentStmt::_internal_set_objtype(::pg_query::ObjectType value) { _impl_.objtype_ = value; } inline void CommentStmt::set_objtype(::pg_query::ObjectType value) { _internal_set_objtype(value); // @@protoc_insertion_point(field_set:pg_query.CommentStmt.objtype) } // .pg_query.Node object = 2 [json_name = "object"]; inline bool CommentStmt::_internal_has_object() const { return this != internal_default_instance() && _impl_.object_ != nullptr; } inline bool CommentStmt::has_object() const { return _internal_has_object(); } inline void CommentStmt::clear_object() { if (GetArenaForAllocation() == nullptr && _impl_.object_ != nullptr) { delete _impl_.object_; } _impl_.object_ = nullptr; } inline const ::pg_query::Node& CommentStmt::_internal_object() const { const ::pg_query::Node* p = _impl_.object_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& CommentStmt::object() const { // @@protoc_insertion_point(field_get:pg_query.CommentStmt.object) return _internal_object(); } inline void CommentStmt::unsafe_arena_set_allocated_object( ::pg_query::Node* object) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.object_); } _impl_.object_ = object; if (object) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CommentStmt.object) } inline ::pg_query::Node* CommentStmt::release_object() { ::pg_query::Node* temp = _impl_.object_; _impl_.object_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* CommentStmt::unsafe_arena_release_object() { // @@protoc_insertion_point(field_release:pg_query.CommentStmt.object) ::pg_query::Node* temp = _impl_.object_; _impl_.object_ = nullptr; return temp; } inline ::pg_query::Node* CommentStmt::_internal_mutable_object() { if (_impl_.object_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.object_ = p; } return _impl_.object_; } inline ::pg_query::Node* CommentStmt::mutable_object() { ::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* object) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.object_; } if (object) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(object); if (message_arena != submessage_arena) { object = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, object, submessage_arena); } } else { } _impl_.object_ = object; // @@protoc_insertion_point(field_set_allocated:pg_query.CommentStmt.object) } // string comment = 3 [json_name = "comment"]; inline void CommentStmt::clear_comment() { _impl_.comment_.ClearToEmpty(); } inline const std::string& CommentStmt::comment() const { // @@protoc_insertion_point(field_get:pg_query.CommentStmt.comment) return _internal_comment(); } template inline PROTOBUF_ALWAYS_INLINE void CommentStmt::set_comment(ArgT0&& arg0, ArgT... args) { _impl_.comment_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CommentStmt.comment) } inline std::string* CommentStmt::mutable_comment() { 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 { return _impl_.comment_.Get(); } inline void CommentStmt::_internal_set_comment(const std::string& value) { _impl_.comment_.Set(value, GetArenaForAllocation()); } inline std::string* CommentStmt::_internal_mutable_comment() { return _impl_.comment_.Mutable(GetArenaForAllocation()); } inline std::string* CommentStmt::release_comment() { // @@protoc_insertion_point(field_release:pg_query.CommentStmt.comment) return _impl_.comment_.Release(); } inline void CommentStmt::set_allocated_comment(std::string* comment) { if (comment != nullptr) { } else { } _impl_.comment_.SetAllocated(comment, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.comment_.IsDefault()) { _impl_.comment_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:pg_query.CommentStmt.comment) } // ------------------------------------------------------------------- // FetchStmt // .pg_query.FetchDirection direction = 1 [json_name = "direction"]; inline void FetchStmt::clear_direction() { _impl_.direction_ = 0; } inline ::pg_query::FetchDirection FetchStmt::_internal_direction() const { return static_cast< ::pg_query::FetchDirection >(_impl_.direction_); } inline ::pg_query::FetchDirection FetchStmt::direction() const { // @@protoc_insertion_point(field_get:pg_query.FetchStmt.direction) return _internal_direction(); } inline void FetchStmt::_internal_set_direction(::pg_query::FetchDirection value) { _impl_.direction_ = value; } inline void FetchStmt::set_direction(::pg_query::FetchDirection value) { _internal_set_direction(value); // @@protoc_insertion_point(field_set:pg_query.FetchStmt.direction) } // int64 how_many = 2 [json_name = "howMany"]; inline void FetchStmt::clear_how_many() { _impl_.how_many_ = int64_t{0}; } inline int64_t FetchStmt::_internal_how_many() const { return _impl_.how_many_; } inline int64_t FetchStmt::how_many() const { // @@protoc_insertion_point(field_get:pg_query.FetchStmt.how_many) return _internal_how_many(); } inline void FetchStmt::_internal_set_how_many(int64_t value) { _impl_.how_many_ = value; } inline void FetchStmt::set_how_many(int64_t value) { _internal_set_how_many(value); // @@protoc_insertion_point(field_set:pg_query.FetchStmt.how_many) } // string portalname = 3 [json_name = "portalname"]; inline void FetchStmt::clear_portalname() { _impl_.portalname_.ClearToEmpty(); } inline const std::string& FetchStmt::portalname() const { // @@protoc_insertion_point(field_get:pg_query.FetchStmt.portalname) return _internal_portalname(); } template inline PROTOBUF_ALWAYS_INLINE void FetchStmt::set_portalname(ArgT0&& arg0, ArgT... args) { _impl_.portalname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.FetchStmt.portalname) } inline std::string* FetchStmt::mutable_portalname() { 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 { return _impl_.portalname_.Get(); } inline void FetchStmt::_internal_set_portalname(const std::string& value) { _impl_.portalname_.Set(value, GetArenaForAllocation()); } inline std::string* FetchStmt::_internal_mutable_portalname() { return _impl_.portalname_.Mutable(GetArenaForAllocation()); } inline std::string* FetchStmt::release_portalname() { // @@protoc_insertion_point(field_release:pg_query.FetchStmt.portalname) return _impl_.portalname_.Release(); } inline void FetchStmt::set_allocated_portalname(std::string* portalname) { if (portalname != nullptr) { } else { } _impl_.portalname_.SetAllocated(portalname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.portalname_.IsDefault()) { _impl_.portalname_.Set("", GetArenaForAllocation()); } #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() { _impl_.ismove_ = false; } inline bool FetchStmt::_internal_ismove() const { return _impl_.ismove_; } inline bool FetchStmt::ismove() const { // @@protoc_insertion_point(field_get:pg_query.FetchStmt.ismove) return _internal_ismove(); } inline void FetchStmt::_internal_set_ismove(bool value) { _impl_.ismove_ = value; } inline void FetchStmt::set_ismove(bool value) { _internal_set_ismove(value); // @@protoc_insertion_point(field_set:pg_query.FetchStmt.ismove) } // ------------------------------------------------------------------- // IndexStmt // string idxname = 1 [json_name = "idxname"]; inline void IndexStmt::clear_idxname() { _impl_.idxname_.ClearToEmpty(); } inline const std::string& IndexStmt::idxname() const { // @@protoc_insertion_point(field_get:pg_query.IndexStmt.idxname) return _internal_idxname(); } template inline PROTOBUF_ALWAYS_INLINE void IndexStmt::set_idxname(ArgT0&& arg0, ArgT... args) { _impl_.idxname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.IndexStmt.idxname) } inline std::string* IndexStmt::mutable_idxname() { 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 { return _impl_.idxname_.Get(); } inline void IndexStmt::_internal_set_idxname(const std::string& value) { _impl_.idxname_.Set(value, GetArenaForAllocation()); } inline std::string* IndexStmt::_internal_mutable_idxname() { return _impl_.idxname_.Mutable(GetArenaForAllocation()); } inline std::string* IndexStmt::release_idxname() { // @@protoc_insertion_point(field_release:pg_query.IndexStmt.idxname) return _impl_.idxname_.Release(); } inline void IndexStmt::set_allocated_idxname(std::string* idxname) { if (idxname != nullptr) { } else { } _impl_.idxname_.SetAllocated(idxname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.idxname_.IsDefault()) { _impl_.idxname_.Set("", GetArenaForAllocation()); } #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::_internal_has_relation() const { return this != internal_default_instance() && _impl_.relation_ != nullptr; } inline bool IndexStmt::has_relation() const { return _internal_has_relation(); } inline void IndexStmt::clear_relation() { if (GetArenaForAllocation() == nullptr && _impl_.relation_ != nullptr) { delete _impl_.relation_; } _impl_.relation_ = nullptr; } inline const ::pg_query::RangeVar& IndexStmt::_internal_relation() const { const ::pg_query::RangeVar* p = _impl_.relation_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& IndexStmt::relation() const { // @@protoc_insertion_point(field_get:pg_query.IndexStmt.relation) return _internal_relation(); } inline void IndexStmt::unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.relation_); } _impl_.relation_ = relation; if (relation) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.IndexStmt.relation) } inline ::pg_query::RangeVar* IndexStmt::release_relation() { ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* IndexStmt::unsafe_arena_release_relation() { // @@protoc_insertion_point(field_release:pg_query.IndexStmt.relation) ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; return temp; } inline ::pg_query::RangeVar* IndexStmt::_internal_mutable_relation() { if (_impl_.relation_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.relation_ = p; } return _impl_.relation_; } inline ::pg_query::RangeVar* IndexStmt::mutable_relation() { ::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* relation) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.relation_; } if (relation) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(relation); if (message_arena != submessage_arena) { relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, relation, submessage_arena); } } else { } _impl_.relation_ = relation; // @@protoc_insertion_point(field_set_allocated:pg_query.IndexStmt.relation) } // string access_method = 3 [json_name = "accessMethod"]; inline void IndexStmt::clear_access_method() { _impl_.access_method_.ClearToEmpty(); } inline const std::string& IndexStmt::access_method() const { // @@protoc_insertion_point(field_get:pg_query.IndexStmt.access_method) return _internal_access_method(); } template inline PROTOBUF_ALWAYS_INLINE void IndexStmt::set_access_method(ArgT0&& arg0, ArgT... args) { _impl_.access_method_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.IndexStmt.access_method) } inline std::string* IndexStmt::mutable_access_method() { 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 { return _impl_.access_method_.Get(); } inline void IndexStmt::_internal_set_access_method(const std::string& value) { _impl_.access_method_.Set(value, GetArenaForAllocation()); } inline std::string* IndexStmt::_internal_mutable_access_method() { return _impl_.access_method_.Mutable(GetArenaForAllocation()); } inline std::string* IndexStmt::release_access_method() { // @@protoc_insertion_point(field_release:pg_query.IndexStmt.access_method) return _impl_.access_method_.Release(); } inline void IndexStmt::set_allocated_access_method(std::string* access_method) { if (access_method != nullptr) { } else { } _impl_.access_method_.SetAllocated(access_method, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.access_method_.IsDefault()) { _impl_.access_method_.Set("", GetArenaForAllocation()); } #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() { _impl_.table_space_.ClearToEmpty(); } inline const std::string& IndexStmt::table_space() const { // @@protoc_insertion_point(field_get:pg_query.IndexStmt.table_space) return _internal_table_space(); } template inline PROTOBUF_ALWAYS_INLINE void IndexStmt::set_table_space(ArgT0&& arg0, ArgT... args) { _impl_.table_space_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.IndexStmt.table_space) } inline std::string* IndexStmt::mutable_table_space() { 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 { return _impl_.table_space_.Get(); } inline void IndexStmt::_internal_set_table_space(const std::string& value) { _impl_.table_space_.Set(value, GetArenaForAllocation()); } inline std::string* IndexStmt::_internal_mutable_table_space() { return _impl_.table_space_.Mutable(GetArenaForAllocation()); } inline std::string* IndexStmt::release_table_space() { // @@protoc_insertion_point(field_release:pg_query.IndexStmt.table_space) return _impl_.table_space_.Release(); } inline void IndexStmt::set_allocated_table_space(std::string* table_space) { if (table_space != nullptr) { } else { } _impl_.table_space_.SetAllocated(table_space, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.table_space_.IsDefault()) { _impl_.table_space_.Set("", GetArenaForAllocation()); } #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 _impl_.index_params_.size(); } inline int IndexStmt::index_params_size() const { return _internal_index_params_size(); } inline void IndexStmt::clear_index_params() { _impl_.index_params_.Clear(); } inline ::pg_query::Node* IndexStmt::mutable_index_params(int index) { // @@protoc_insertion_point(field_mutable:pg_query.IndexStmt.index_params) return _impl_.index_params_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* IndexStmt::mutable_index_params() { // @@protoc_insertion_point(field_mutable_list:pg_query.IndexStmt.index_params) return &_impl_.index_params_; } inline const ::pg_query::Node& IndexStmt::_internal_index_params(int index) const { return _impl_.index_params_.Get(index); } inline const ::pg_query::Node& IndexStmt::index_params(int index) const { // @@protoc_insertion_point(field_get:pg_query.IndexStmt.index_params) return _internal_index_params(index); } inline ::pg_query::Node* IndexStmt::_internal_add_index_params() { return _impl_.index_params_.Add(); } inline ::pg_query::Node* IndexStmt::add_index_params() { ::pg_query::Node* _add = _internal_add_index_params(); // @@protoc_insertion_point(field_add:pg_query.IndexStmt.index_params) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& IndexStmt::index_params() const { // @@protoc_insertion_point(field_list:pg_query.IndexStmt.index_params) 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 _impl_.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() { _impl_.index_including_params_.Clear(); } inline ::pg_query::Node* IndexStmt::mutable_index_including_params(int index) { // @@protoc_insertion_point(field_mutable:pg_query.IndexStmt.index_including_params) return _impl_.index_including_params_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* IndexStmt::mutable_index_including_params() { // @@protoc_insertion_point(field_mutable_list:pg_query.IndexStmt.index_including_params) return &_impl_.index_including_params_; } inline const ::pg_query::Node& IndexStmt::_internal_index_including_params(int index) const { return _impl_.index_including_params_.Get(index); } inline const ::pg_query::Node& IndexStmt::index_including_params(int index) const { // @@protoc_insertion_point(field_get:pg_query.IndexStmt.index_including_params) return _internal_index_including_params(index); } inline ::pg_query::Node* IndexStmt::_internal_add_index_including_params() { return _impl_.index_including_params_.Add(); } inline ::pg_query::Node* IndexStmt::add_index_including_params() { ::pg_query::Node* _add = _internal_add_index_including_params(); // @@protoc_insertion_point(field_add:pg_query.IndexStmt.index_including_params) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& IndexStmt::index_including_params() const { // @@protoc_insertion_point(field_list:pg_query.IndexStmt.index_including_params) return _impl_.index_including_params_; } // repeated .pg_query.Node options = 7 [json_name = "options"]; inline int IndexStmt::_internal_options_size() const { return _impl_.options_.size(); } inline int IndexStmt::options_size() const { return _internal_options_size(); } inline void IndexStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* IndexStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.IndexStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* IndexStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.IndexStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& IndexStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& IndexStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.IndexStmt.options) return _internal_options(index); } inline ::pg_query::Node* IndexStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* IndexStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.IndexStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& IndexStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.IndexStmt.options) return _impl_.options_; } // .pg_query.Node where_clause = 8 [json_name = "whereClause"]; inline bool IndexStmt::_internal_has_where_clause() const { return this != internal_default_instance() && _impl_.where_clause_ != nullptr; } inline bool IndexStmt::has_where_clause() const { return _internal_has_where_clause(); } inline void IndexStmt::clear_where_clause() { if (GetArenaForAllocation() == nullptr && _impl_.where_clause_ != nullptr) { delete _impl_.where_clause_; } _impl_.where_clause_ = nullptr; } inline const ::pg_query::Node& IndexStmt::_internal_where_clause() const { const ::pg_query::Node* p = _impl_.where_clause_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& IndexStmt::where_clause() const { // @@protoc_insertion_point(field_get:pg_query.IndexStmt.where_clause) return _internal_where_clause(); } inline void IndexStmt::unsafe_arena_set_allocated_where_clause( ::pg_query::Node* where_clause) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.where_clause_); } _impl_.where_clause_ = where_clause; if (where_clause) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.IndexStmt.where_clause) } inline ::pg_query::Node* IndexStmt::release_where_clause() { ::pg_query::Node* temp = _impl_.where_clause_; _impl_.where_clause_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* IndexStmt::unsafe_arena_release_where_clause() { // @@protoc_insertion_point(field_release:pg_query.IndexStmt.where_clause) ::pg_query::Node* temp = _impl_.where_clause_; _impl_.where_clause_ = nullptr; return temp; } inline ::pg_query::Node* IndexStmt::_internal_mutable_where_clause() { if (_impl_.where_clause_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.where_clause_ = p; } return _impl_.where_clause_; } inline ::pg_query::Node* IndexStmt::mutable_where_clause() { ::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* where_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.where_clause_; } if (where_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(where_clause); if (message_arena != submessage_arena) { where_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, where_clause, submessage_arena); } } else { } _impl_.where_clause_ = where_clause; // @@protoc_insertion_point(field_set_allocated:pg_query.IndexStmt.where_clause) } // repeated .pg_query.Node exclude_op_names = 9 [json_name = "excludeOpNames"]; inline int IndexStmt::_internal_exclude_op_names_size() const { return _impl_.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() { _impl_.exclude_op_names_.Clear(); } inline ::pg_query::Node* IndexStmt::mutable_exclude_op_names(int index) { // @@protoc_insertion_point(field_mutable:pg_query.IndexStmt.exclude_op_names) return _impl_.exclude_op_names_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* IndexStmt::mutable_exclude_op_names() { // @@protoc_insertion_point(field_mutable_list:pg_query.IndexStmt.exclude_op_names) return &_impl_.exclude_op_names_; } inline const ::pg_query::Node& IndexStmt::_internal_exclude_op_names(int index) const { return _impl_.exclude_op_names_.Get(index); } inline const ::pg_query::Node& IndexStmt::exclude_op_names(int index) const { // @@protoc_insertion_point(field_get:pg_query.IndexStmt.exclude_op_names) return _internal_exclude_op_names(index); } inline ::pg_query::Node* IndexStmt::_internal_add_exclude_op_names() { return _impl_.exclude_op_names_.Add(); } inline ::pg_query::Node* IndexStmt::add_exclude_op_names() { ::pg_query::Node* _add = _internal_add_exclude_op_names(); // @@protoc_insertion_point(field_add:pg_query.IndexStmt.exclude_op_names) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& IndexStmt::exclude_op_names() const { // @@protoc_insertion_point(field_list:pg_query.IndexStmt.exclude_op_names) return _impl_.exclude_op_names_; } // string idxcomment = 10 [json_name = "idxcomment"]; inline void IndexStmt::clear_idxcomment() { _impl_.idxcomment_.ClearToEmpty(); } inline const std::string& IndexStmt::idxcomment() const { // @@protoc_insertion_point(field_get:pg_query.IndexStmt.idxcomment) return _internal_idxcomment(); } template inline PROTOBUF_ALWAYS_INLINE void IndexStmt::set_idxcomment(ArgT0&& arg0, ArgT... args) { _impl_.idxcomment_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.IndexStmt.idxcomment) } inline std::string* IndexStmt::mutable_idxcomment() { 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 { return _impl_.idxcomment_.Get(); } inline void IndexStmt::_internal_set_idxcomment(const std::string& value) { _impl_.idxcomment_.Set(value, GetArenaForAllocation()); } inline std::string* IndexStmt::_internal_mutable_idxcomment() { return _impl_.idxcomment_.Mutable(GetArenaForAllocation()); } inline std::string* IndexStmt::release_idxcomment() { // @@protoc_insertion_point(field_release:pg_query.IndexStmt.idxcomment) return _impl_.idxcomment_.Release(); } inline void IndexStmt::set_allocated_idxcomment(std::string* idxcomment) { if (idxcomment != nullptr) { } else { } _impl_.idxcomment_.SetAllocated(idxcomment, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.idxcomment_.IsDefault()) { _impl_.idxcomment_.Set("", GetArenaForAllocation()); } #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() { _impl_.index_oid_ = 0u; } inline uint32_t IndexStmt::_internal_index_oid() const { return _impl_.index_oid_; } inline uint32_t IndexStmt::index_oid() const { // @@protoc_insertion_point(field_get:pg_query.IndexStmt.index_oid) return _internal_index_oid(); } inline void IndexStmt::_internal_set_index_oid(uint32_t value) { _impl_.index_oid_ = value; } inline void IndexStmt::set_index_oid(uint32_t value) { _internal_set_index_oid(value); // @@protoc_insertion_point(field_set:pg_query.IndexStmt.index_oid) } // uint32 old_node = 12 [json_name = "oldNode"]; inline void IndexStmt::clear_old_node() { _impl_.old_node_ = 0u; } inline uint32_t IndexStmt::_internal_old_node() const { return _impl_.old_node_; } inline uint32_t IndexStmt::old_node() const { // @@protoc_insertion_point(field_get:pg_query.IndexStmt.old_node) return _internal_old_node(); } inline void IndexStmt::_internal_set_old_node(uint32_t value) { _impl_.old_node_ = value; } inline void IndexStmt::set_old_node(uint32_t value) { _internal_set_old_node(value); // @@protoc_insertion_point(field_set:pg_query.IndexStmt.old_node) } // uint32 old_create_subid = 13 [json_name = "oldCreateSubid"]; inline void IndexStmt::clear_old_create_subid() { _impl_.old_create_subid_ = 0u; } inline uint32_t IndexStmt::_internal_old_create_subid() const { return _impl_.old_create_subid_; } 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::_internal_set_old_create_subid(uint32_t value) { _impl_.old_create_subid_ = value; } 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) } // uint32 old_first_relfilenode_subid = 14 [json_name = "oldFirstRelfilenodeSubid"]; inline void IndexStmt::clear_old_first_relfilenode_subid() { _impl_.old_first_relfilenode_subid_ = 0u; } inline uint32_t IndexStmt::_internal_old_first_relfilenode_subid() const { return _impl_.old_first_relfilenode_subid_; } inline uint32_t IndexStmt::old_first_relfilenode_subid() const { // @@protoc_insertion_point(field_get:pg_query.IndexStmt.old_first_relfilenode_subid) return _internal_old_first_relfilenode_subid(); } inline void IndexStmt::_internal_set_old_first_relfilenode_subid(uint32_t value) { _impl_.old_first_relfilenode_subid_ = value; } inline void IndexStmt::set_old_first_relfilenode_subid(uint32_t value) { _internal_set_old_first_relfilenode_subid(value); // @@protoc_insertion_point(field_set:pg_query.IndexStmt.old_first_relfilenode_subid) } // bool unique = 15 [json_name = "unique"]; inline void IndexStmt::clear_unique() { _impl_.unique_ = false; } inline bool IndexStmt::_internal_unique() const { return _impl_.unique_; } inline bool IndexStmt::unique() const { // @@protoc_insertion_point(field_get:pg_query.IndexStmt.unique) return _internal_unique(); } inline void IndexStmt::_internal_set_unique(bool value) { _impl_.unique_ = value; } inline void IndexStmt::set_unique(bool value) { _internal_set_unique(value); // @@protoc_insertion_point(field_set:pg_query.IndexStmt.unique) } // bool nulls_not_distinct = 16 [json_name = "nulls_not_distinct"]; inline void IndexStmt::clear_nulls_not_distinct() { _impl_.nulls_not_distinct_ = false; } inline bool IndexStmt::_internal_nulls_not_distinct() const { return _impl_.nulls_not_distinct_; } 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::_internal_set_nulls_not_distinct(bool value) { _impl_.nulls_not_distinct_ = value; } 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) } // bool primary = 17 [json_name = "primary"]; inline void IndexStmt::clear_primary() { _impl_.primary_ = false; } inline bool IndexStmt::_internal_primary() const { return _impl_.primary_; } inline bool IndexStmt::primary() const { // @@protoc_insertion_point(field_get:pg_query.IndexStmt.primary) return _internal_primary(); } inline void IndexStmt::_internal_set_primary(bool value) { _impl_.primary_ = value; } inline void IndexStmt::set_primary(bool value) { _internal_set_primary(value); // @@protoc_insertion_point(field_set:pg_query.IndexStmt.primary) } // bool isconstraint = 18 [json_name = "isconstraint"]; inline void IndexStmt::clear_isconstraint() { _impl_.isconstraint_ = false; } inline bool IndexStmt::_internal_isconstraint() const { return _impl_.isconstraint_; } inline bool IndexStmt::isconstraint() const { // @@protoc_insertion_point(field_get:pg_query.IndexStmt.isconstraint) return _internal_isconstraint(); } inline void IndexStmt::_internal_set_isconstraint(bool value) { _impl_.isconstraint_ = value; } inline void IndexStmt::set_isconstraint(bool value) { _internal_set_isconstraint(value); // @@protoc_insertion_point(field_set:pg_query.IndexStmt.isconstraint) } // bool deferrable = 19 [json_name = "deferrable"]; inline void IndexStmt::clear_deferrable() { _impl_.deferrable_ = false; } inline bool IndexStmt::_internal_deferrable() const { return _impl_.deferrable_; } inline bool IndexStmt::deferrable() const { // @@protoc_insertion_point(field_get:pg_query.IndexStmt.deferrable) return _internal_deferrable(); } inline void IndexStmt::_internal_set_deferrable(bool value) { _impl_.deferrable_ = value; } inline void IndexStmt::set_deferrable(bool value) { _internal_set_deferrable(value); // @@protoc_insertion_point(field_set:pg_query.IndexStmt.deferrable) } // bool initdeferred = 20 [json_name = "initdeferred"]; inline void IndexStmt::clear_initdeferred() { _impl_.initdeferred_ = false; } inline bool IndexStmt::_internal_initdeferred() const { return _impl_.initdeferred_; } inline bool IndexStmt::initdeferred() const { // @@protoc_insertion_point(field_get:pg_query.IndexStmt.initdeferred) return _internal_initdeferred(); } inline void IndexStmt::_internal_set_initdeferred(bool value) { _impl_.initdeferred_ = value; } inline void IndexStmt::set_initdeferred(bool value) { _internal_set_initdeferred(value); // @@protoc_insertion_point(field_set:pg_query.IndexStmt.initdeferred) } // bool transformed = 21 [json_name = "transformed"]; inline void IndexStmt::clear_transformed() { _impl_.transformed_ = false; } inline bool IndexStmt::_internal_transformed() const { return _impl_.transformed_; } inline bool IndexStmt::transformed() const { // @@protoc_insertion_point(field_get:pg_query.IndexStmt.transformed) return _internal_transformed(); } inline void IndexStmt::_internal_set_transformed(bool value) { _impl_.transformed_ = value; } inline void IndexStmt::set_transformed(bool value) { _internal_set_transformed(value); // @@protoc_insertion_point(field_set:pg_query.IndexStmt.transformed) } // bool concurrent = 22 [json_name = "concurrent"]; inline void IndexStmt::clear_concurrent() { _impl_.concurrent_ = false; } inline bool IndexStmt::_internal_concurrent() const { return _impl_.concurrent_; } inline bool IndexStmt::concurrent() const { // @@protoc_insertion_point(field_get:pg_query.IndexStmt.concurrent) return _internal_concurrent(); } inline void IndexStmt::_internal_set_concurrent(bool value) { _impl_.concurrent_ = value; } inline void IndexStmt::set_concurrent(bool value) { _internal_set_concurrent(value); // @@protoc_insertion_point(field_set:pg_query.IndexStmt.concurrent) } // bool if_not_exists = 23 [json_name = "if_not_exists"]; inline void IndexStmt::clear_if_not_exists() { _impl_.if_not_exists_ = false; } inline bool IndexStmt::_internal_if_not_exists() const { return _impl_.if_not_exists_; } inline bool IndexStmt::if_not_exists() const { // @@protoc_insertion_point(field_get:pg_query.IndexStmt.if_not_exists) return _internal_if_not_exists(); } inline void IndexStmt::_internal_set_if_not_exists(bool value) { _impl_.if_not_exists_ = value; } inline void IndexStmt::set_if_not_exists(bool value) { _internal_set_if_not_exists(value); // @@protoc_insertion_point(field_set:pg_query.IndexStmt.if_not_exists) } // bool reset_default_tblspc = 24 [json_name = "reset_default_tblspc"]; inline void IndexStmt::clear_reset_default_tblspc() { _impl_.reset_default_tblspc_ = false; } inline bool IndexStmt::_internal_reset_default_tblspc() const { return _impl_.reset_default_tblspc_; } inline bool IndexStmt::reset_default_tblspc() const { // @@protoc_insertion_point(field_get:pg_query.IndexStmt.reset_default_tblspc) return _internal_reset_default_tblspc(); } inline void IndexStmt::_internal_set_reset_default_tblspc(bool value) { _impl_.reset_default_tblspc_ = value; } inline void IndexStmt::set_reset_default_tblspc(bool value) { _internal_set_reset_default_tblspc(value); // @@protoc_insertion_point(field_set:pg_query.IndexStmt.reset_default_tblspc) } // ------------------------------------------------------------------- // CreateFunctionStmt // bool is_procedure = 1 [json_name = "is_procedure"]; inline void CreateFunctionStmt::clear_is_procedure() { _impl_.is_procedure_ = false; } inline bool CreateFunctionStmt::_internal_is_procedure() const { return _impl_.is_procedure_; } inline bool CreateFunctionStmt::is_procedure() const { // @@protoc_insertion_point(field_get:pg_query.CreateFunctionStmt.is_procedure) return _internal_is_procedure(); } inline void CreateFunctionStmt::_internal_set_is_procedure(bool value) { _impl_.is_procedure_ = value; } inline void CreateFunctionStmt::set_is_procedure(bool value) { _internal_set_is_procedure(value); // @@protoc_insertion_point(field_set:pg_query.CreateFunctionStmt.is_procedure) } // bool replace = 2 [json_name = "replace"]; inline void CreateFunctionStmt::clear_replace() { _impl_.replace_ = false; } inline bool CreateFunctionStmt::_internal_replace() const { return _impl_.replace_; } inline bool CreateFunctionStmt::replace() const { // @@protoc_insertion_point(field_get:pg_query.CreateFunctionStmt.replace) return _internal_replace(); } inline void CreateFunctionStmt::_internal_set_replace(bool value) { _impl_.replace_ = value; } inline void CreateFunctionStmt::set_replace(bool value) { _internal_set_replace(value); // @@protoc_insertion_point(field_set:pg_query.CreateFunctionStmt.replace) } // repeated .pg_query.Node funcname = 3 [json_name = "funcname"]; inline int CreateFunctionStmt::_internal_funcname_size() const { return _impl_.funcname_.size(); } inline int CreateFunctionStmt::funcname_size() const { return _internal_funcname_size(); } inline void CreateFunctionStmt::clear_funcname() { _impl_.funcname_.Clear(); } inline ::pg_query::Node* CreateFunctionStmt::mutable_funcname(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateFunctionStmt.funcname) return _impl_.funcname_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateFunctionStmt::mutable_funcname() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateFunctionStmt.funcname) return &_impl_.funcname_; } inline const ::pg_query::Node& CreateFunctionStmt::_internal_funcname(int index) const { return _impl_.funcname_.Get(index); } inline const ::pg_query::Node& CreateFunctionStmt::funcname(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateFunctionStmt.funcname) return _internal_funcname(index); } inline ::pg_query::Node* CreateFunctionStmt::_internal_add_funcname() { return _impl_.funcname_.Add(); } inline ::pg_query::Node* CreateFunctionStmt::add_funcname() { ::pg_query::Node* _add = _internal_add_funcname(); // @@protoc_insertion_point(field_add:pg_query.CreateFunctionStmt.funcname) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateFunctionStmt::funcname() const { // @@protoc_insertion_point(field_list:pg_query.CreateFunctionStmt.funcname) return _impl_.funcname_; } // repeated .pg_query.Node parameters = 4 [json_name = "parameters"]; inline int CreateFunctionStmt::_internal_parameters_size() const { return _impl_.parameters_.size(); } inline int CreateFunctionStmt::parameters_size() const { return _internal_parameters_size(); } inline void CreateFunctionStmt::clear_parameters() { _impl_.parameters_.Clear(); } inline ::pg_query::Node* CreateFunctionStmt::mutable_parameters(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateFunctionStmt.parameters) return _impl_.parameters_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateFunctionStmt::mutable_parameters() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateFunctionStmt.parameters) return &_impl_.parameters_; } inline const ::pg_query::Node& CreateFunctionStmt::_internal_parameters(int index) const { return _impl_.parameters_.Get(index); } inline const ::pg_query::Node& CreateFunctionStmt::parameters(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateFunctionStmt.parameters) return _internal_parameters(index); } inline ::pg_query::Node* CreateFunctionStmt::_internal_add_parameters() { return _impl_.parameters_.Add(); } inline ::pg_query::Node* CreateFunctionStmt::add_parameters() { ::pg_query::Node* _add = _internal_add_parameters(); // @@protoc_insertion_point(field_add:pg_query.CreateFunctionStmt.parameters) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateFunctionStmt::parameters() const { // @@protoc_insertion_point(field_list:pg_query.CreateFunctionStmt.parameters) return _impl_.parameters_; } // .pg_query.TypeName return_type = 5 [json_name = "returnType"]; inline bool CreateFunctionStmt::_internal_has_return_type() const { return this != internal_default_instance() && _impl_.return_type_ != nullptr; } inline bool CreateFunctionStmt::has_return_type() const { return _internal_has_return_type(); } inline void CreateFunctionStmt::clear_return_type() { if (GetArenaForAllocation() == nullptr && _impl_.return_type_ != nullptr) { delete _impl_.return_type_; } _impl_.return_type_ = nullptr; } inline const ::pg_query::TypeName& CreateFunctionStmt::_internal_return_type() const { const ::pg_query::TypeName* p = _impl_.return_type_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_TypeName_default_instance_); } inline const ::pg_query::TypeName& CreateFunctionStmt::return_type() const { // @@protoc_insertion_point(field_get:pg_query.CreateFunctionStmt.return_type) return _internal_return_type(); } inline void CreateFunctionStmt::unsafe_arena_set_allocated_return_type( ::pg_query::TypeName* return_type) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.return_type_); } _impl_.return_type_ = return_type; if (return_type) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateFunctionStmt.return_type) } inline ::pg_query::TypeName* CreateFunctionStmt::release_return_type() { ::pg_query::TypeName* temp = _impl_.return_type_; _impl_.return_type_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::TypeName* CreateFunctionStmt::unsafe_arena_release_return_type() { // @@protoc_insertion_point(field_release:pg_query.CreateFunctionStmt.return_type) ::pg_query::TypeName* temp = _impl_.return_type_; _impl_.return_type_ = nullptr; return temp; } inline ::pg_query::TypeName* CreateFunctionStmt::_internal_mutable_return_type() { if (_impl_.return_type_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArenaForAllocation()); _impl_.return_type_ = p; } return _impl_.return_type_; } inline ::pg_query::TypeName* CreateFunctionStmt::mutable_return_type() { ::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* return_type) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.return_type_; } if (return_type) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(return_type); if (message_arena != submessage_arena) { return_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, return_type, submessage_arena); } } else { } _impl_.return_type_ = return_type; // @@protoc_insertion_point(field_set_allocated:pg_query.CreateFunctionStmt.return_type) } // repeated .pg_query.Node options = 6 [json_name = "options"]; inline int CreateFunctionStmt::_internal_options_size() const { return _impl_.options_.size(); } inline int CreateFunctionStmt::options_size() const { return _internal_options_size(); } inline void CreateFunctionStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* CreateFunctionStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateFunctionStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateFunctionStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateFunctionStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& CreateFunctionStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& CreateFunctionStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateFunctionStmt.options) return _internal_options(index); } inline ::pg_query::Node* CreateFunctionStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* CreateFunctionStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.CreateFunctionStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateFunctionStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.CreateFunctionStmt.options) return _impl_.options_; } // .pg_query.Node sql_body = 7 [json_name = "sql_body"]; inline bool CreateFunctionStmt::_internal_has_sql_body() const { return this != internal_default_instance() && _impl_.sql_body_ != nullptr; } inline bool CreateFunctionStmt::has_sql_body() const { return _internal_has_sql_body(); } inline void CreateFunctionStmt::clear_sql_body() { if (GetArenaForAllocation() == nullptr && _impl_.sql_body_ != nullptr) { delete _impl_.sql_body_; } _impl_.sql_body_ = nullptr; } inline const ::pg_query::Node& CreateFunctionStmt::_internal_sql_body() const { const ::pg_query::Node* p = _impl_.sql_body_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& CreateFunctionStmt::sql_body() const { // @@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* sql_body) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.sql_body_); } _impl_.sql_body_ = sql_body; if (sql_body) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateFunctionStmt.sql_body) } inline ::pg_query::Node* CreateFunctionStmt::release_sql_body() { ::pg_query::Node* temp = _impl_.sql_body_; _impl_.sql_body_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* CreateFunctionStmt::unsafe_arena_release_sql_body() { // @@protoc_insertion_point(field_release:pg_query.CreateFunctionStmt.sql_body) ::pg_query::Node* temp = _impl_.sql_body_; _impl_.sql_body_ = nullptr; return temp; } inline ::pg_query::Node* CreateFunctionStmt::_internal_mutable_sql_body() { if (_impl_.sql_body_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.sql_body_ = p; } return _impl_.sql_body_; } inline ::pg_query::Node* CreateFunctionStmt::mutable_sql_body() { ::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* sql_body) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.sql_body_; } if (sql_body) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(sql_body); if (message_arena != submessage_arena) { sql_body = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, sql_body, submessage_arena); } } else { } _impl_.sql_body_ = sql_body; // @@protoc_insertion_point(field_set_allocated:pg_query.CreateFunctionStmt.sql_body) } // ------------------------------------------------------------------- // AlterFunctionStmt // .pg_query.ObjectType objtype = 1 [json_name = "objtype"]; inline void AlterFunctionStmt::clear_objtype() { _impl_.objtype_ = 0; } inline ::pg_query::ObjectType AlterFunctionStmt::_internal_objtype() const { return static_cast< ::pg_query::ObjectType >(_impl_.objtype_); } inline ::pg_query::ObjectType AlterFunctionStmt::objtype() const { // @@protoc_insertion_point(field_get:pg_query.AlterFunctionStmt.objtype) return _internal_objtype(); } inline void AlterFunctionStmt::_internal_set_objtype(::pg_query::ObjectType value) { _impl_.objtype_ = value; } inline void AlterFunctionStmt::set_objtype(::pg_query::ObjectType value) { _internal_set_objtype(value); // @@protoc_insertion_point(field_set:pg_query.AlterFunctionStmt.objtype) } // .pg_query.ObjectWithArgs func = 2 [json_name = "func"]; inline bool AlterFunctionStmt::_internal_has_func() const { return this != internal_default_instance() && _impl_.func_ != nullptr; } inline bool AlterFunctionStmt::has_func() const { return _internal_has_func(); } inline void AlterFunctionStmt::clear_func() { if (GetArenaForAllocation() == nullptr && _impl_.func_ != nullptr) { delete _impl_.func_; } _impl_.func_ = nullptr; } inline const ::pg_query::ObjectWithArgs& AlterFunctionStmt::_internal_func() const { const ::pg_query::ObjectWithArgs* p = _impl_.func_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_ObjectWithArgs_default_instance_); } inline const ::pg_query::ObjectWithArgs& AlterFunctionStmt::func() const { // @@protoc_insertion_point(field_get:pg_query.AlterFunctionStmt.func) return _internal_func(); } inline void AlterFunctionStmt::unsafe_arena_set_allocated_func( ::pg_query::ObjectWithArgs* func) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.func_); } _impl_.func_ = func; if (func) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterFunctionStmt.func) } inline ::pg_query::ObjectWithArgs* AlterFunctionStmt::release_func() { ::pg_query::ObjectWithArgs* temp = _impl_.func_; _impl_.func_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::ObjectWithArgs* AlterFunctionStmt::unsafe_arena_release_func() { // @@protoc_insertion_point(field_release:pg_query.AlterFunctionStmt.func) ::pg_query::ObjectWithArgs* temp = _impl_.func_; _impl_.func_ = nullptr; return temp; } inline ::pg_query::ObjectWithArgs* AlterFunctionStmt::_internal_mutable_func() { if (_impl_.func_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::ObjectWithArgs>(GetArenaForAllocation()); _impl_.func_ = p; } return _impl_.func_; } inline ::pg_query::ObjectWithArgs* AlterFunctionStmt::mutable_func() { ::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* func) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.func_; } if (func) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(func); if (message_arena != submessage_arena) { func = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, func, submessage_arena); } } else { } _impl_.func_ = func; // @@protoc_insertion_point(field_set_allocated:pg_query.AlterFunctionStmt.func) } // repeated .pg_query.Node actions = 3 [json_name = "actions"]; inline int AlterFunctionStmt::_internal_actions_size() const { return _impl_.actions_.size(); } inline int AlterFunctionStmt::actions_size() const { return _internal_actions_size(); } inline void AlterFunctionStmt::clear_actions() { _impl_.actions_.Clear(); } inline ::pg_query::Node* AlterFunctionStmt::mutable_actions(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterFunctionStmt.actions) return _impl_.actions_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterFunctionStmt::mutable_actions() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterFunctionStmt.actions) return &_impl_.actions_; } inline const ::pg_query::Node& AlterFunctionStmt::_internal_actions(int index) const { return _impl_.actions_.Get(index); } inline const ::pg_query::Node& AlterFunctionStmt::actions(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterFunctionStmt.actions) return _internal_actions(index); } inline ::pg_query::Node* AlterFunctionStmt::_internal_add_actions() { return _impl_.actions_.Add(); } inline ::pg_query::Node* AlterFunctionStmt::add_actions() { ::pg_query::Node* _add = _internal_add_actions(); // @@protoc_insertion_point(field_add:pg_query.AlterFunctionStmt.actions) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterFunctionStmt::actions() const { // @@protoc_insertion_point(field_list:pg_query.AlterFunctionStmt.actions) return _impl_.actions_; } // ------------------------------------------------------------------- // DoStmt // repeated .pg_query.Node args = 1 [json_name = "args"]; inline int DoStmt::_internal_args_size() const { return _impl_.args_.size(); } inline int DoStmt::args_size() const { return _internal_args_size(); } inline void DoStmt::clear_args() { _impl_.args_.Clear(); } inline ::pg_query::Node* DoStmt::mutable_args(int index) { // @@protoc_insertion_point(field_mutable:pg_query.DoStmt.args) return _impl_.args_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* DoStmt::mutable_args() { // @@protoc_insertion_point(field_mutable_list:pg_query.DoStmt.args) return &_impl_.args_; } inline const ::pg_query::Node& DoStmt::_internal_args(int index) const { return _impl_.args_.Get(index); } inline const ::pg_query::Node& DoStmt::args(int index) const { // @@protoc_insertion_point(field_get:pg_query.DoStmt.args) return _internal_args(index); } inline ::pg_query::Node* DoStmt::_internal_add_args() { return _impl_.args_.Add(); } inline ::pg_query::Node* DoStmt::add_args() { ::pg_query::Node* _add = _internal_add_args(); // @@protoc_insertion_point(field_add:pg_query.DoStmt.args) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& DoStmt::args() const { // @@protoc_insertion_point(field_list:pg_query.DoStmt.args) return _impl_.args_; } // ------------------------------------------------------------------- // RenameStmt // .pg_query.ObjectType rename_type = 1 [json_name = "renameType"]; inline void RenameStmt::clear_rename_type() { _impl_.rename_type_ = 0; } inline ::pg_query::ObjectType RenameStmt::_internal_rename_type() const { return static_cast< ::pg_query::ObjectType >(_impl_.rename_type_); } inline ::pg_query::ObjectType RenameStmt::rename_type() const { // @@protoc_insertion_point(field_get:pg_query.RenameStmt.rename_type) return _internal_rename_type(); } inline void RenameStmt::_internal_set_rename_type(::pg_query::ObjectType value) { _impl_.rename_type_ = value; } inline void RenameStmt::set_rename_type(::pg_query::ObjectType value) { _internal_set_rename_type(value); // @@protoc_insertion_point(field_set:pg_query.RenameStmt.rename_type) } // .pg_query.ObjectType relation_type = 2 [json_name = "relationType"]; inline void RenameStmt::clear_relation_type() { _impl_.relation_type_ = 0; } inline ::pg_query::ObjectType RenameStmt::_internal_relation_type() const { return static_cast< ::pg_query::ObjectType >(_impl_.relation_type_); } inline ::pg_query::ObjectType RenameStmt::relation_type() const { // @@protoc_insertion_point(field_get:pg_query.RenameStmt.relation_type) return _internal_relation_type(); } inline void RenameStmt::_internal_set_relation_type(::pg_query::ObjectType value) { _impl_.relation_type_ = value; } inline void RenameStmt::set_relation_type(::pg_query::ObjectType value) { _internal_set_relation_type(value); // @@protoc_insertion_point(field_set:pg_query.RenameStmt.relation_type) } // .pg_query.RangeVar relation = 3 [json_name = "relation"]; inline bool RenameStmt::_internal_has_relation() const { return this != internal_default_instance() && _impl_.relation_ != nullptr; } inline bool RenameStmt::has_relation() const { return _internal_has_relation(); } inline void RenameStmt::clear_relation() { if (GetArenaForAllocation() == nullptr && _impl_.relation_ != nullptr) { delete _impl_.relation_; } _impl_.relation_ = nullptr; } inline const ::pg_query::RangeVar& RenameStmt::_internal_relation() const { const ::pg_query::RangeVar* p = _impl_.relation_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& RenameStmt::relation() const { // @@protoc_insertion_point(field_get:pg_query.RenameStmt.relation) return _internal_relation(); } inline void RenameStmt::unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.relation_); } _impl_.relation_ = relation; if (relation) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RenameStmt.relation) } inline ::pg_query::RangeVar* RenameStmt::release_relation() { ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* RenameStmt::unsafe_arena_release_relation() { // @@protoc_insertion_point(field_release:pg_query.RenameStmt.relation) ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; return temp; } inline ::pg_query::RangeVar* RenameStmt::_internal_mutable_relation() { if (_impl_.relation_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.relation_ = p; } return _impl_.relation_; } inline ::pg_query::RangeVar* RenameStmt::mutable_relation() { ::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* relation) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.relation_; } if (relation) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(relation); if (message_arena != submessage_arena) { relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, relation, submessage_arena); } } else { } _impl_.relation_ = relation; // @@protoc_insertion_point(field_set_allocated:pg_query.RenameStmt.relation) } // .pg_query.Node object = 4 [json_name = "object"]; inline bool RenameStmt::_internal_has_object() const { return this != internal_default_instance() && _impl_.object_ != nullptr; } inline bool RenameStmt::has_object() const { return _internal_has_object(); } inline void RenameStmt::clear_object() { if (GetArenaForAllocation() == nullptr && _impl_.object_ != nullptr) { delete _impl_.object_; } _impl_.object_ = nullptr; } inline const ::pg_query::Node& RenameStmt::_internal_object() const { const ::pg_query::Node* p = _impl_.object_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& RenameStmt::object() const { // @@protoc_insertion_point(field_get:pg_query.RenameStmt.object) return _internal_object(); } inline void RenameStmt::unsafe_arena_set_allocated_object( ::pg_query::Node* object) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.object_); } _impl_.object_ = object; if (object) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RenameStmt.object) } inline ::pg_query::Node* RenameStmt::release_object() { ::pg_query::Node* temp = _impl_.object_; _impl_.object_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* RenameStmt::unsafe_arena_release_object() { // @@protoc_insertion_point(field_release:pg_query.RenameStmt.object) ::pg_query::Node* temp = _impl_.object_; _impl_.object_ = nullptr; return temp; } inline ::pg_query::Node* RenameStmt::_internal_mutable_object() { if (_impl_.object_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.object_ = p; } return _impl_.object_; } inline ::pg_query::Node* RenameStmt::mutable_object() { ::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* object) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.object_; } if (object) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(object); if (message_arena != submessage_arena) { object = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, object, submessage_arena); } } else { } _impl_.object_ = object; // @@protoc_insertion_point(field_set_allocated:pg_query.RenameStmt.object) } // string subname = 5 [json_name = "subname"]; inline void RenameStmt::clear_subname() { _impl_.subname_.ClearToEmpty(); } inline const std::string& RenameStmt::subname() const { // @@protoc_insertion_point(field_get:pg_query.RenameStmt.subname) return _internal_subname(); } template inline PROTOBUF_ALWAYS_INLINE void RenameStmt::set_subname(ArgT0&& arg0, ArgT... args) { _impl_.subname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.RenameStmt.subname) } inline std::string* RenameStmt::mutable_subname() { 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 { return _impl_.subname_.Get(); } inline void RenameStmt::_internal_set_subname(const std::string& value) { _impl_.subname_.Set(value, GetArenaForAllocation()); } inline std::string* RenameStmt::_internal_mutable_subname() { return _impl_.subname_.Mutable(GetArenaForAllocation()); } inline std::string* RenameStmt::release_subname() { // @@protoc_insertion_point(field_release:pg_query.RenameStmt.subname) return _impl_.subname_.Release(); } inline void RenameStmt::set_allocated_subname(std::string* subname) { if (subname != nullptr) { } else { } _impl_.subname_.SetAllocated(subname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.subname_.IsDefault()) { _impl_.subname_.Set("", GetArenaForAllocation()); } #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() { _impl_.newname_.ClearToEmpty(); } inline const std::string& RenameStmt::newname() const { // @@protoc_insertion_point(field_get:pg_query.RenameStmt.newname) return _internal_newname(); } template inline PROTOBUF_ALWAYS_INLINE void RenameStmt::set_newname(ArgT0&& arg0, ArgT... args) { _impl_.newname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.RenameStmt.newname) } inline std::string* RenameStmt::mutable_newname() { 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 { return _impl_.newname_.Get(); } inline void RenameStmt::_internal_set_newname(const std::string& value) { _impl_.newname_.Set(value, GetArenaForAllocation()); } inline std::string* RenameStmt::_internal_mutable_newname() { return _impl_.newname_.Mutable(GetArenaForAllocation()); } inline std::string* RenameStmt::release_newname() { // @@protoc_insertion_point(field_release:pg_query.RenameStmt.newname) return _impl_.newname_.Release(); } inline void RenameStmt::set_allocated_newname(std::string* newname) { if (newname != nullptr) { } else { } _impl_.newname_.SetAllocated(newname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.newname_.IsDefault()) { _impl_.newname_.Set("", GetArenaForAllocation()); } #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() { _impl_.behavior_ = 0; } inline ::pg_query::DropBehavior RenameStmt::_internal_behavior() const { return static_cast< ::pg_query::DropBehavior >(_impl_.behavior_); } inline ::pg_query::DropBehavior RenameStmt::behavior() const { // @@protoc_insertion_point(field_get:pg_query.RenameStmt.behavior) return _internal_behavior(); } inline void RenameStmt::_internal_set_behavior(::pg_query::DropBehavior value) { _impl_.behavior_ = value; } inline void RenameStmt::set_behavior(::pg_query::DropBehavior value) { _internal_set_behavior(value); // @@protoc_insertion_point(field_set:pg_query.RenameStmt.behavior) } // bool missing_ok = 8 [json_name = "missing_ok"]; inline void RenameStmt::clear_missing_ok() { _impl_.missing_ok_ = false; } inline bool RenameStmt::_internal_missing_ok() const { return _impl_.missing_ok_; } inline bool RenameStmt::missing_ok() const { // @@protoc_insertion_point(field_get:pg_query.RenameStmt.missing_ok) return _internal_missing_ok(); } inline void RenameStmt::_internal_set_missing_ok(bool value) { _impl_.missing_ok_ = value; } inline void RenameStmt::set_missing_ok(bool value) { _internal_set_missing_ok(value); // @@protoc_insertion_point(field_set:pg_query.RenameStmt.missing_ok) } // ------------------------------------------------------------------- // RuleStmt // .pg_query.RangeVar relation = 1 [json_name = "relation"]; inline bool RuleStmt::_internal_has_relation() const { return this != internal_default_instance() && _impl_.relation_ != nullptr; } inline bool RuleStmt::has_relation() const { return _internal_has_relation(); } inline void RuleStmt::clear_relation() { if (GetArenaForAllocation() == nullptr && _impl_.relation_ != nullptr) { delete _impl_.relation_; } _impl_.relation_ = nullptr; } inline const ::pg_query::RangeVar& RuleStmt::_internal_relation() const { const ::pg_query::RangeVar* p = _impl_.relation_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& RuleStmt::relation() const { // @@protoc_insertion_point(field_get:pg_query.RuleStmt.relation) return _internal_relation(); } inline void RuleStmt::unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.relation_); } _impl_.relation_ = relation; if (relation) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RuleStmt.relation) } inline ::pg_query::RangeVar* RuleStmt::release_relation() { ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* RuleStmt::unsafe_arena_release_relation() { // @@protoc_insertion_point(field_release:pg_query.RuleStmt.relation) ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; return temp; } inline ::pg_query::RangeVar* RuleStmt::_internal_mutable_relation() { if (_impl_.relation_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.relation_ = p; } return _impl_.relation_; } inline ::pg_query::RangeVar* RuleStmt::mutable_relation() { ::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* relation) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.relation_; } if (relation) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(relation); if (message_arena != submessage_arena) { relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, relation, submessage_arena); } } else { } _impl_.relation_ = relation; // @@protoc_insertion_point(field_set_allocated:pg_query.RuleStmt.relation) } // string rulename = 2 [json_name = "rulename"]; inline void RuleStmt::clear_rulename() { _impl_.rulename_.ClearToEmpty(); } inline const std::string& RuleStmt::rulename() const { // @@protoc_insertion_point(field_get:pg_query.RuleStmt.rulename) return _internal_rulename(); } template inline PROTOBUF_ALWAYS_INLINE void RuleStmt::set_rulename(ArgT0&& arg0, ArgT... args) { _impl_.rulename_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.RuleStmt.rulename) } inline std::string* RuleStmt::mutable_rulename() { 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 { return _impl_.rulename_.Get(); } inline void RuleStmt::_internal_set_rulename(const std::string& value) { _impl_.rulename_.Set(value, GetArenaForAllocation()); } inline std::string* RuleStmt::_internal_mutable_rulename() { return _impl_.rulename_.Mutable(GetArenaForAllocation()); } inline std::string* RuleStmt::release_rulename() { // @@protoc_insertion_point(field_release:pg_query.RuleStmt.rulename) return _impl_.rulename_.Release(); } inline void RuleStmt::set_allocated_rulename(std::string* rulename) { if (rulename != nullptr) { } else { } _impl_.rulename_.SetAllocated(rulename, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.rulename_.IsDefault()) { _impl_.rulename_.Set("", GetArenaForAllocation()); } #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::_internal_has_where_clause() const { return this != internal_default_instance() && _impl_.where_clause_ != nullptr; } inline bool RuleStmt::has_where_clause() const { return _internal_has_where_clause(); } inline void RuleStmt::clear_where_clause() { if (GetArenaForAllocation() == nullptr && _impl_.where_clause_ != nullptr) { delete _impl_.where_clause_; } _impl_.where_clause_ = nullptr; } inline const ::pg_query::Node& RuleStmt::_internal_where_clause() const { const ::pg_query::Node* p = _impl_.where_clause_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& RuleStmt::where_clause() const { // @@protoc_insertion_point(field_get:pg_query.RuleStmt.where_clause) return _internal_where_clause(); } inline void RuleStmt::unsafe_arena_set_allocated_where_clause( ::pg_query::Node* where_clause) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.where_clause_); } _impl_.where_clause_ = where_clause; if (where_clause) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RuleStmt.where_clause) } inline ::pg_query::Node* RuleStmt::release_where_clause() { ::pg_query::Node* temp = _impl_.where_clause_; _impl_.where_clause_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* RuleStmt::unsafe_arena_release_where_clause() { // @@protoc_insertion_point(field_release:pg_query.RuleStmt.where_clause) ::pg_query::Node* temp = _impl_.where_clause_; _impl_.where_clause_ = nullptr; return temp; } inline ::pg_query::Node* RuleStmt::_internal_mutable_where_clause() { if (_impl_.where_clause_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.where_clause_ = p; } return _impl_.where_clause_; } inline ::pg_query::Node* RuleStmt::mutable_where_clause() { ::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* where_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.where_clause_; } if (where_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(where_clause); if (message_arena != submessage_arena) { where_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, where_clause, submessage_arena); } } else { } _impl_.where_clause_ = where_clause; // @@protoc_insertion_point(field_set_allocated:pg_query.RuleStmt.where_clause) } // .pg_query.CmdType event = 4 [json_name = "event"]; inline void RuleStmt::clear_event() { _impl_.event_ = 0; } inline ::pg_query::CmdType RuleStmt::_internal_event() const { return static_cast< ::pg_query::CmdType >(_impl_.event_); } inline ::pg_query::CmdType RuleStmt::event() const { // @@protoc_insertion_point(field_get:pg_query.RuleStmt.event) return _internal_event(); } inline void RuleStmt::_internal_set_event(::pg_query::CmdType value) { _impl_.event_ = value; } inline void RuleStmt::set_event(::pg_query::CmdType value) { _internal_set_event(value); // @@protoc_insertion_point(field_set:pg_query.RuleStmt.event) } // bool instead = 5 [json_name = "instead"]; inline void RuleStmt::clear_instead() { _impl_.instead_ = false; } inline bool RuleStmt::_internal_instead() const { return _impl_.instead_; } inline bool RuleStmt::instead() const { // @@protoc_insertion_point(field_get:pg_query.RuleStmt.instead) return _internal_instead(); } inline void RuleStmt::_internal_set_instead(bool value) { _impl_.instead_ = value; } inline void RuleStmt::set_instead(bool value) { _internal_set_instead(value); // @@protoc_insertion_point(field_set:pg_query.RuleStmt.instead) } // repeated .pg_query.Node actions = 6 [json_name = "actions"]; inline int RuleStmt::_internal_actions_size() const { return _impl_.actions_.size(); } inline int RuleStmt::actions_size() const { return _internal_actions_size(); } inline void RuleStmt::clear_actions() { _impl_.actions_.Clear(); } inline ::pg_query::Node* RuleStmt::mutable_actions(int index) { // @@protoc_insertion_point(field_mutable:pg_query.RuleStmt.actions) return _impl_.actions_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* RuleStmt::mutable_actions() { // @@protoc_insertion_point(field_mutable_list:pg_query.RuleStmt.actions) return &_impl_.actions_; } inline const ::pg_query::Node& RuleStmt::_internal_actions(int index) const { return _impl_.actions_.Get(index); } inline const ::pg_query::Node& RuleStmt::actions(int index) const { // @@protoc_insertion_point(field_get:pg_query.RuleStmt.actions) return _internal_actions(index); } inline ::pg_query::Node* RuleStmt::_internal_add_actions() { return _impl_.actions_.Add(); } inline ::pg_query::Node* RuleStmt::add_actions() { ::pg_query::Node* _add = _internal_add_actions(); // @@protoc_insertion_point(field_add:pg_query.RuleStmt.actions) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& RuleStmt::actions() const { // @@protoc_insertion_point(field_list:pg_query.RuleStmt.actions) return _impl_.actions_; } // bool replace = 7 [json_name = "replace"]; inline void RuleStmt::clear_replace() { _impl_.replace_ = false; } inline bool RuleStmt::_internal_replace() const { return _impl_.replace_; } inline bool RuleStmt::replace() const { // @@protoc_insertion_point(field_get:pg_query.RuleStmt.replace) return _internal_replace(); } inline void RuleStmt::_internal_set_replace(bool value) { _impl_.replace_ = value; } inline void RuleStmt::set_replace(bool value) { _internal_set_replace(value); // @@protoc_insertion_point(field_set:pg_query.RuleStmt.replace) } // ------------------------------------------------------------------- // NotifyStmt // string conditionname = 1 [json_name = "conditionname"]; inline void NotifyStmt::clear_conditionname() { _impl_.conditionname_.ClearToEmpty(); } inline const std::string& NotifyStmt::conditionname() const { // @@protoc_insertion_point(field_get:pg_query.NotifyStmt.conditionname) return _internal_conditionname(); } template inline PROTOBUF_ALWAYS_INLINE void NotifyStmt::set_conditionname(ArgT0&& arg0, ArgT... args) { _impl_.conditionname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.NotifyStmt.conditionname) } inline std::string* NotifyStmt::mutable_conditionname() { 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 { return _impl_.conditionname_.Get(); } inline void NotifyStmt::_internal_set_conditionname(const std::string& value) { _impl_.conditionname_.Set(value, GetArenaForAllocation()); } inline std::string* NotifyStmt::_internal_mutable_conditionname() { return _impl_.conditionname_.Mutable(GetArenaForAllocation()); } inline std::string* NotifyStmt::release_conditionname() { // @@protoc_insertion_point(field_release:pg_query.NotifyStmt.conditionname) return _impl_.conditionname_.Release(); } inline void NotifyStmt::set_allocated_conditionname(std::string* conditionname) { if (conditionname != nullptr) { } else { } _impl_.conditionname_.SetAllocated(conditionname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.conditionname_.IsDefault()) { _impl_.conditionname_.Set("", GetArenaForAllocation()); } #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() { _impl_.payload_.ClearToEmpty(); } inline const std::string& NotifyStmt::payload() const { // @@protoc_insertion_point(field_get:pg_query.NotifyStmt.payload) return _internal_payload(); } template inline PROTOBUF_ALWAYS_INLINE void NotifyStmt::set_payload(ArgT0&& arg0, ArgT... args) { _impl_.payload_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.NotifyStmt.payload) } inline std::string* NotifyStmt::mutable_payload() { 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 { return _impl_.payload_.Get(); } inline void NotifyStmt::_internal_set_payload(const std::string& value) { _impl_.payload_.Set(value, GetArenaForAllocation()); } inline std::string* NotifyStmt::_internal_mutable_payload() { return _impl_.payload_.Mutable(GetArenaForAllocation()); } inline std::string* NotifyStmt::release_payload() { // @@protoc_insertion_point(field_release:pg_query.NotifyStmt.payload) return _impl_.payload_.Release(); } inline void NotifyStmt::set_allocated_payload(std::string* payload) { if (payload != nullptr) { } else { } _impl_.payload_.SetAllocated(payload, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.payload_.IsDefault()) { _impl_.payload_.Set("", GetArenaForAllocation()); } #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() { _impl_.conditionname_.ClearToEmpty(); } inline const std::string& ListenStmt::conditionname() const { // @@protoc_insertion_point(field_get:pg_query.ListenStmt.conditionname) return _internal_conditionname(); } template inline PROTOBUF_ALWAYS_INLINE void ListenStmt::set_conditionname(ArgT0&& arg0, ArgT... args) { _impl_.conditionname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.ListenStmt.conditionname) } inline std::string* ListenStmt::mutable_conditionname() { 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 { return _impl_.conditionname_.Get(); } inline void ListenStmt::_internal_set_conditionname(const std::string& value) { _impl_.conditionname_.Set(value, GetArenaForAllocation()); } inline std::string* ListenStmt::_internal_mutable_conditionname() { return _impl_.conditionname_.Mutable(GetArenaForAllocation()); } inline std::string* ListenStmt::release_conditionname() { // @@protoc_insertion_point(field_release:pg_query.ListenStmt.conditionname) return _impl_.conditionname_.Release(); } inline void ListenStmt::set_allocated_conditionname(std::string* conditionname) { if (conditionname != nullptr) { } else { } _impl_.conditionname_.SetAllocated(conditionname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.conditionname_.IsDefault()) { _impl_.conditionname_.Set("", GetArenaForAllocation()); } #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() { _impl_.conditionname_.ClearToEmpty(); } inline const std::string& UnlistenStmt::conditionname() const { // @@protoc_insertion_point(field_get:pg_query.UnlistenStmt.conditionname) return _internal_conditionname(); } template inline PROTOBUF_ALWAYS_INLINE void UnlistenStmt::set_conditionname(ArgT0&& arg0, ArgT... args) { _impl_.conditionname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.UnlistenStmt.conditionname) } inline std::string* UnlistenStmt::mutable_conditionname() { 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 { return _impl_.conditionname_.Get(); } inline void UnlistenStmt::_internal_set_conditionname(const std::string& value) { _impl_.conditionname_.Set(value, GetArenaForAllocation()); } inline std::string* UnlistenStmt::_internal_mutable_conditionname() { return _impl_.conditionname_.Mutable(GetArenaForAllocation()); } inline std::string* UnlistenStmt::release_conditionname() { // @@protoc_insertion_point(field_release:pg_query.UnlistenStmt.conditionname) return _impl_.conditionname_.Release(); } inline void UnlistenStmt::set_allocated_conditionname(std::string* conditionname) { if (conditionname != nullptr) { } else { } _impl_.conditionname_.SetAllocated(conditionname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.conditionname_.IsDefault()) { _impl_.conditionname_.Set("", GetArenaForAllocation()); } #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() { _impl_.kind_ = 0; } inline ::pg_query::TransactionStmtKind TransactionStmt::_internal_kind() const { return static_cast< ::pg_query::TransactionStmtKind >(_impl_.kind_); } inline ::pg_query::TransactionStmtKind TransactionStmt::kind() const { // @@protoc_insertion_point(field_get:pg_query.TransactionStmt.kind) return _internal_kind(); } inline void TransactionStmt::_internal_set_kind(::pg_query::TransactionStmtKind value) { _impl_.kind_ = value; } inline void TransactionStmt::set_kind(::pg_query::TransactionStmtKind value) { _internal_set_kind(value); // @@protoc_insertion_point(field_set:pg_query.TransactionStmt.kind) } // repeated .pg_query.Node options = 2 [json_name = "options"]; inline int TransactionStmt::_internal_options_size() const { return _impl_.options_.size(); } inline int TransactionStmt::options_size() const { return _internal_options_size(); } inline void TransactionStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* TransactionStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.TransactionStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* TransactionStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.TransactionStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& TransactionStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& TransactionStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.TransactionStmt.options) return _internal_options(index); } inline ::pg_query::Node* TransactionStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* TransactionStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.TransactionStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& TransactionStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.TransactionStmt.options) return _impl_.options_; } // string savepoint_name = 3 [json_name = "savepoint_name"]; inline void TransactionStmt::clear_savepoint_name() { _impl_.savepoint_name_.ClearToEmpty(); } inline const std::string& TransactionStmt::savepoint_name() const { // @@protoc_insertion_point(field_get:pg_query.TransactionStmt.savepoint_name) return _internal_savepoint_name(); } template inline PROTOBUF_ALWAYS_INLINE void TransactionStmt::set_savepoint_name(ArgT0&& arg0, ArgT... args) { _impl_.savepoint_name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.TransactionStmt.savepoint_name) } inline std::string* TransactionStmt::mutable_savepoint_name() { 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 { return _impl_.savepoint_name_.Get(); } inline void TransactionStmt::_internal_set_savepoint_name(const std::string& value) { _impl_.savepoint_name_.Set(value, GetArenaForAllocation()); } inline std::string* TransactionStmt::_internal_mutable_savepoint_name() { return _impl_.savepoint_name_.Mutable(GetArenaForAllocation()); } inline std::string* TransactionStmt::release_savepoint_name() { // @@protoc_insertion_point(field_release:pg_query.TransactionStmt.savepoint_name) return _impl_.savepoint_name_.Release(); } inline void TransactionStmt::set_allocated_savepoint_name(std::string* savepoint_name) { if (savepoint_name != nullptr) { } else { } _impl_.savepoint_name_.SetAllocated(savepoint_name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.savepoint_name_.IsDefault()) { _impl_.savepoint_name_.Set("", GetArenaForAllocation()); } #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() { _impl_.gid_.ClearToEmpty(); } inline const std::string& TransactionStmt::gid() const { // @@protoc_insertion_point(field_get:pg_query.TransactionStmt.gid) return _internal_gid(); } template inline PROTOBUF_ALWAYS_INLINE void TransactionStmt::set_gid(ArgT0&& arg0, ArgT... args) { _impl_.gid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.TransactionStmt.gid) } inline std::string* TransactionStmt::mutable_gid() { 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 { return _impl_.gid_.Get(); } inline void TransactionStmt::_internal_set_gid(const std::string& value) { _impl_.gid_.Set(value, GetArenaForAllocation()); } inline std::string* TransactionStmt::_internal_mutable_gid() { return _impl_.gid_.Mutable(GetArenaForAllocation()); } inline std::string* TransactionStmt::release_gid() { // @@protoc_insertion_point(field_release:pg_query.TransactionStmt.gid) return _impl_.gid_.Release(); } inline void TransactionStmt::set_allocated_gid(std::string* gid) { if (gid != nullptr) { } else { } _impl_.gid_.SetAllocated(gid, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.gid_.IsDefault()) { _impl_.gid_.Set("", GetArenaForAllocation()); } #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() { _impl_.chain_ = false; } inline bool TransactionStmt::_internal_chain() const { return _impl_.chain_; } inline bool TransactionStmt::chain() const { // @@protoc_insertion_point(field_get:pg_query.TransactionStmt.chain) return _internal_chain(); } inline void TransactionStmt::_internal_set_chain(bool value) { _impl_.chain_ = value; } inline void TransactionStmt::set_chain(bool value) { _internal_set_chain(value); // @@protoc_insertion_point(field_set:pg_query.TransactionStmt.chain) } // ------------------------------------------------------------------- // ViewStmt // .pg_query.RangeVar view = 1 [json_name = "view"]; inline bool ViewStmt::_internal_has_view() const { return this != internal_default_instance() && _impl_.view_ != nullptr; } inline bool ViewStmt::has_view() const { return _internal_has_view(); } inline void ViewStmt::clear_view() { if (GetArenaForAllocation() == nullptr && _impl_.view_ != nullptr) { delete _impl_.view_; } _impl_.view_ = nullptr; } inline const ::pg_query::RangeVar& ViewStmt::_internal_view() const { const ::pg_query::RangeVar* p = _impl_.view_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& ViewStmt::view() const { // @@protoc_insertion_point(field_get:pg_query.ViewStmt.view) return _internal_view(); } inline void ViewStmt::unsafe_arena_set_allocated_view( ::pg_query::RangeVar* view) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.view_); } _impl_.view_ = view; if (view) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ViewStmt.view) } inline ::pg_query::RangeVar* ViewStmt::release_view() { ::pg_query::RangeVar* temp = _impl_.view_; _impl_.view_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* ViewStmt::unsafe_arena_release_view() { // @@protoc_insertion_point(field_release:pg_query.ViewStmt.view) ::pg_query::RangeVar* temp = _impl_.view_; _impl_.view_ = nullptr; return temp; } inline ::pg_query::RangeVar* ViewStmt::_internal_mutable_view() { if (_impl_.view_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.view_ = p; } return _impl_.view_; } inline ::pg_query::RangeVar* ViewStmt::mutable_view() { ::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* view) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.view_; } if (view) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(view); if (message_arena != submessage_arena) { view = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, view, submessage_arena); } } else { } _impl_.view_ = view; // @@protoc_insertion_point(field_set_allocated:pg_query.ViewStmt.view) } // repeated .pg_query.Node aliases = 2 [json_name = "aliases"]; inline int ViewStmt::_internal_aliases_size() const { return _impl_.aliases_.size(); } inline int ViewStmt::aliases_size() const { return _internal_aliases_size(); } inline void ViewStmt::clear_aliases() { _impl_.aliases_.Clear(); } inline ::pg_query::Node* ViewStmt::mutable_aliases(int index) { // @@protoc_insertion_point(field_mutable:pg_query.ViewStmt.aliases) return _impl_.aliases_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* ViewStmt::mutable_aliases() { // @@protoc_insertion_point(field_mutable_list:pg_query.ViewStmt.aliases) return &_impl_.aliases_; } inline const ::pg_query::Node& ViewStmt::_internal_aliases(int index) const { return _impl_.aliases_.Get(index); } inline const ::pg_query::Node& ViewStmt::aliases(int index) const { // @@protoc_insertion_point(field_get:pg_query.ViewStmt.aliases) return _internal_aliases(index); } inline ::pg_query::Node* ViewStmt::_internal_add_aliases() { return _impl_.aliases_.Add(); } inline ::pg_query::Node* ViewStmt::add_aliases() { ::pg_query::Node* _add = _internal_add_aliases(); // @@protoc_insertion_point(field_add:pg_query.ViewStmt.aliases) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& ViewStmt::aliases() const { // @@protoc_insertion_point(field_list:pg_query.ViewStmt.aliases) return _impl_.aliases_; } // .pg_query.Node query = 3 [json_name = "query"]; inline bool ViewStmt::_internal_has_query() const { return this != internal_default_instance() && _impl_.query_ != nullptr; } inline bool ViewStmt::has_query() const { return _internal_has_query(); } inline void ViewStmt::clear_query() { if (GetArenaForAllocation() == nullptr && _impl_.query_ != nullptr) { delete _impl_.query_; } _impl_.query_ = nullptr; } inline const ::pg_query::Node& ViewStmt::_internal_query() const { const ::pg_query::Node* p = _impl_.query_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& ViewStmt::query() const { // @@protoc_insertion_point(field_get:pg_query.ViewStmt.query) return _internal_query(); } inline void ViewStmt::unsafe_arena_set_allocated_query( ::pg_query::Node* query) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.query_); } _impl_.query_ = query; if (query) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ViewStmt.query) } inline ::pg_query::Node* ViewStmt::release_query() { ::pg_query::Node* temp = _impl_.query_; _impl_.query_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* ViewStmt::unsafe_arena_release_query() { // @@protoc_insertion_point(field_release:pg_query.ViewStmt.query) ::pg_query::Node* temp = _impl_.query_; _impl_.query_ = nullptr; return temp; } inline ::pg_query::Node* ViewStmt::_internal_mutable_query() { if (_impl_.query_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.query_ = p; } return _impl_.query_; } inline ::pg_query::Node* ViewStmt::mutable_query() { ::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* query) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.query_; } if (query) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(query); if (message_arena != submessage_arena) { query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, query, submessage_arena); } } else { } _impl_.query_ = query; // @@protoc_insertion_point(field_set_allocated:pg_query.ViewStmt.query) } // bool replace = 4 [json_name = "replace"]; inline void ViewStmt::clear_replace() { _impl_.replace_ = false; } inline bool ViewStmt::_internal_replace() const { return _impl_.replace_; } inline bool ViewStmt::replace() const { // @@protoc_insertion_point(field_get:pg_query.ViewStmt.replace) return _internal_replace(); } inline void ViewStmt::_internal_set_replace(bool value) { _impl_.replace_ = value; } inline void ViewStmt::set_replace(bool value) { _internal_set_replace(value); // @@protoc_insertion_point(field_set:pg_query.ViewStmt.replace) } // repeated .pg_query.Node options = 5 [json_name = "options"]; inline int ViewStmt::_internal_options_size() const { return _impl_.options_.size(); } inline int ViewStmt::options_size() const { return _internal_options_size(); } inline void ViewStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* ViewStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.ViewStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* ViewStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.ViewStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& ViewStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& ViewStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.ViewStmt.options) return _internal_options(index); } inline ::pg_query::Node* ViewStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* ViewStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.ViewStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& ViewStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.ViewStmt.options) return _impl_.options_; } // .pg_query.ViewCheckOption with_check_option = 6 [json_name = "withCheckOption"]; inline void ViewStmt::clear_with_check_option() { _impl_.with_check_option_ = 0; } inline ::pg_query::ViewCheckOption ViewStmt::_internal_with_check_option() const { return static_cast< ::pg_query::ViewCheckOption >(_impl_.with_check_option_); } inline ::pg_query::ViewCheckOption ViewStmt::with_check_option() const { // @@protoc_insertion_point(field_get:pg_query.ViewStmt.with_check_option) return _internal_with_check_option(); } inline void ViewStmt::_internal_set_with_check_option(::pg_query::ViewCheckOption value) { _impl_.with_check_option_ = value; } inline void ViewStmt::set_with_check_option(::pg_query::ViewCheckOption value) { _internal_set_with_check_option(value); // @@protoc_insertion_point(field_set:pg_query.ViewStmt.with_check_option) } // ------------------------------------------------------------------- // LoadStmt // string filename = 1 [json_name = "filename"]; inline void LoadStmt::clear_filename() { _impl_.filename_.ClearToEmpty(); } inline const std::string& LoadStmt::filename() const { // @@protoc_insertion_point(field_get:pg_query.LoadStmt.filename) return _internal_filename(); } template inline PROTOBUF_ALWAYS_INLINE void LoadStmt::set_filename(ArgT0&& arg0, ArgT... args) { _impl_.filename_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.LoadStmt.filename) } inline std::string* LoadStmt::mutable_filename() { 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 { return _impl_.filename_.Get(); } inline void LoadStmt::_internal_set_filename(const std::string& value) { _impl_.filename_.Set(value, GetArenaForAllocation()); } inline std::string* LoadStmt::_internal_mutable_filename() { return _impl_.filename_.Mutable(GetArenaForAllocation()); } inline std::string* LoadStmt::release_filename() { // @@protoc_insertion_point(field_release:pg_query.LoadStmt.filename) return _impl_.filename_.Release(); } inline void LoadStmt::set_allocated_filename(std::string* filename) { if (filename != nullptr) { } else { } _impl_.filename_.SetAllocated(filename, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.filename_.IsDefault()) { _impl_.filename_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:pg_query.LoadStmt.filename) } // ------------------------------------------------------------------- // CreateDomainStmt // repeated .pg_query.Node domainname = 1 [json_name = "domainname"]; inline int CreateDomainStmt::_internal_domainname_size() const { return _impl_.domainname_.size(); } inline int CreateDomainStmt::domainname_size() const { return _internal_domainname_size(); } inline void CreateDomainStmt::clear_domainname() { _impl_.domainname_.Clear(); } inline ::pg_query::Node* CreateDomainStmt::mutable_domainname(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateDomainStmt.domainname) return _impl_.domainname_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateDomainStmt::mutable_domainname() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateDomainStmt.domainname) return &_impl_.domainname_; } inline const ::pg_query::Node& CreateDomainStmt::_internal_domainname(int index) const { return _impl_.domainname_.Get(index); } inline const ::pg_query::Node& CreateDomainStmt::domainname(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateDomainStmt.domainname) return _internal_domainname(index); } inline ::pg_query::Node* CreateDomainStmt::_internal_add_domainname() { return _impl_.domainname_.Add(); } inline ::pg_query::Node* CreateDomainStmt::add_domainname() { ::pg_query::Node* _add = _internal_add_domainname(); // @@protoc_insertion_point(field_add:pg_query.CreateDomainStmt.domainname) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateDomainStmt::domainname() const { // @@protoc_insertion_point(field_list:pg_query.CreateDomainStmt.domainname) return _impl_.domainname_; } // .pg_query.TypeName type_name = 2 [json_name = "typeName"]; inline bool CreateDomainStmt::_internal_has_type_name() const { return this != internal_default_instance() && _impl_.type_name_ != nullptr; } inline bool CreateDomainStmt::has_type_name() const { return _internal_has_type_name(); } inline void CreateDomainStmt::clear_type_name() { if (GetArenaForAllocation() == nullptr && _impl_.type_name_ != nullptr) { delete _impl_.type_name_; } _impl_.type_name_ = nullptr; } inline const ::pg_query::TypeName& CreateDomainStmt::_internal_type_name() const { const ::pg_query::TypeName* p = _impl_.type_name_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_TypeName_default_instance_); } inline const ::pg_query::TypeName& CreateDomainStmt::type_name() const { // @@protoc_insertion_point(field_get:pg_query.CreateDomainStmt.type_name) return _internal_type_name(); } inline void CreateDomainStmt::unsafe_arena_set_allocated_type_name( ::pg_query::TypeName* type_name) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.type_name_); } _impl_.type_name_ = type_name; if (type_name) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateDomainStmt.type_name) } inline ::pg_query::TypeName* CreateDomainStmt::release_type_name() { ::pg_query::TypeName* temp = _impl_.type_name_; _impl_.type_name_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::TypeName* CreateDomainStmt::unsafe_arena_release_type_name() { // @@protoc_insertion_point(field_release:pg_query.CreateDomainStmt.type_name) ::pg_query::TypeName* temp = _impl_.type_name_; _impl_.type_name_ = nullptr; return temp; } inline ::pg_query::TypeName* CreateDomainStmt::_internal_mutable_type_name() { if (_impl_.type_name_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArenaForAllocation()); _impl_.type_name_ = p; } return _impl_.type_name_; } inline ::pg_query::TypeName* CreateDomainStmt::mutable_type_name() { ::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* type_name) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.type_name_; } if (type_name) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(type_name); if (message_arena != submessage_arena) { type_name = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, type_name, submessage_arena); } } else { } _impl_.type_name_ = type_name; // @@protoc_insertion_point(field_set_allocated:pg_query.CreateDomainStmt.type_name) } // .pg_query.CollateClause coll_clause = 3 [json_name = "collClause"]; inline bool CreateDomainStmt::_internal_has_coll_clause() const { return this != internal_default_instance() && _impl_.coll_clause_ != nullptr; } inline bool CreateDomainStmt::has_coll_clause() const { return _internal_has_coll_clause(); } inline void CreateDomainStmt::clear_coll_clause() { if (GetArenaForAllocation() == nullptr && _impl_.coll_clause_ != nullptr) { delete _impl_.coll_clause_; } _impl_.coll_clause_ = nullptr; } inline const ::pg_query::CollateClause& CreateDomainStmt::_internal_coll_clause() const { const ::pg_query::CollateClause* p = _impl_.coll_clause_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_CollateClause_default_instance_); } inline const ::pg_query::CollateClause& CreateDomainStmt::coll_clause() const { // @@protoc_insertion_point(field_get:pg_query.CreateDomainStmt.coll_clause) return _internal_coll_clause(); } inline void CreateDomainStmt::unsafe_arena_set_allocated_coll_clause( ::pg_query::CollateClause* coll_clause) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.coll_clause_); } _impl_.coll_clause_ = coll_clause; if (coll_clause) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateDomainStmt.coll_clause) } inline ::pg_query::CollateClause* CreateDomainStmt::release_coll_clause() { ::pg_query::CollateClause* temp = _impl_.coll_clause_; _impl_.coll_clause_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::CollateClause* CreateDomainStmt::unsafe_arena_release_coll_clause() { // @@protoc_insertion_point(field_release:pg_query.CreateDomainStmt.coll_clause) ::pg_query::CollateClause* temp = _impl_.coll_clause_; _impl_.coll_clause_ = nullptr; return temp; } inline ::pg_query::CollateClause* CreateDomainStmt::_internal_mutable_coll_clause() { if (_impl_.coll_clause_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::CollateClause>(GetArenaForAllocation()); _impl_.coll_clause_ = p; } return _impl_.coll_clause_; } inline ::pg_query::CollateClause* CreateDomainStmt::mutable_coll_clause() { ::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* coll_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.coll_clause_; } if (coll_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(coll_clause); if (message_arena != submessage_arena) { coll_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, coll_clause, submessage_arena); } } else { } _impl_.coll_clause_ = coll_clause; // @@protoc_insertion_point(field_set_allocated:pg_query.CreateDomainStmt.coll_clause) } // repeated .pg_query.Node constraints = 4 [json_name = "constraints"]; inline int CreateDomainStmt::_internal_constraints_size() const { return _impl_.constraints_.size(); } inline int CreateDomainStmt::constraints_size() const { return _internal_constraints_size(); } inline void CreateDomainStmt::clear_constraints() { _impl_.constraints_.Clear(); } inline ::pg_query::Node* CreateDomainStmt::mutable_constraints(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateDomainStmt.constraints) return _impl_.constraints_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateDomainStmt::mutable_constraints() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateDomainStmt.constraints) return &_impl_.constraints_; } inline const ::pg_query::Node& CreateDomainStmt::_internal_constraints(int index) const { return _impl_.constraints_.Get(index); } inline const ::pg_query::Node& CreateDomainStmt::constraints(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateDomainStmt.constraints) return _internal_constraints(index); } inline ::pg_query::Node* CreateDomainStmt::_internal_add_constraints() { return _impl_.constraints_.Add(); } inline ::pg_query::Node* CreateDomainStmt::add_constraints() { ::pg_query::Node* _add = _internal_add_constraints(); // @@protoc_insertion_point(field_add:pg_query.CreateDomainStmt.constraints) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateDomainStmt::constraints() const { // @@protoc_insertion_point(field_list:pg_query.CreateDomainStmt.constraints) return _impl_.constraints_; } // ------------------------------------------------------------------- // CreatedbStmt // string dbname = 1 [json_name = "dbname"]; inline void CreatedbStmt::clear_dbname() { _impl_.dbname_.ClearToEmpty(); } inline const std::string& CreatedbStmt::dbname() const { // @@protoc_insertion_point(field_get:pg_query.CreatedbStmt.dbname) return _internal_dbname(); } template inline PROTOBUF_ALWAYS_INLINE void CreatedbStmt::set_dbname(ArgT0&& arg0, ArgT... args) { _impl_.dbname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreatedbStmt.dbname) } inline std::string* CreatedbStmt::mutable_dbname() { 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 { return _impl_.dbname_.Get(); } inline void CreatedbStmt::_internal_set_dbname(const std::string& value) { _impl_.dbname_.Set(value, GetArenaForAllocation()); } inline std::string* CreatedbStmt::_internal_mutable_dbname() { return _impl_.dbname_.Mutable(GetArenaForAllocation()); } inline std::string* CreatedbStmt::release_dbname() { // @@protoc_insertion_point(field_release:pg_query.CreatedbStmt.dbname) return _impl_.dbname_.Release(); } inline void CreatedbStmt::set_allocated_dbname(std::string* dbname) { if (dbname != nullptr) { } else { } _impl_.dbname_.SetAllocated(dbname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.dbname_.IsDefault()) { _impl_.dbname_.Set("", GetArenaForAllocation()); } #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 _impl_.options_.size(); } inline int CreatedbStmt::options_size() const { return _internal_options_size(); } inline void CreatedbStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* CreatedbStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreatedbStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreatedbStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreatedbStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& CreatedbStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& CreatedbStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreatedbStmt.options) return _internal_options(index); } inline ::pg_query::Node* CreatedbStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* CreatedbStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.CreatedbStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreatedbStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.CreatedbStmt.options) return _impl_.options_; } // ------------------------------------------------------------------- // DropdbStmt // string dbname = 1 [json_name = "dbname"]; inline void DropdbStmt::clear_dbname() { _impl_.dbname_.ClearToEmpty(); } inline const std::string& DropdbStmt::dbname() const { // @@protoc_insertion_point(field_get:pg_query.DropdbStmt.dbname) return _internal_dbname(); } template inline PROTOBUF_ALWAYS_INLINE void DropdbStmt::set_dbname(ArgT0&& arg0, ArgT... args) { _impl_.dbname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.DropdbStmt.dbname) } inline std::string* DropdbStmt::mutable_dbname() { 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 { return _impl_.dbname_.Get(); } inline void DropdbStmt::_internal_set_dbname(const std::string& value) { _impl_.dbname_.Set(value, GetArenaForAllocation()); } inline std::string* DropdbStmt::_internal_mutable_dbname() { return _impl_.dbname_.Mutable(GetArenaForAllocation()); } inline std::string* DropdbStmt::release_dbname() { // @@protoc_insertion_point(field_release:pg_query.DropdbStmt.dbname) return _impl_.dbname_.Release(); } inline void DropdbStmt::set_allocated_dbname(std::string* dbname) { if (dbname != nullptr) { } else { } _impl_.dbname_.SetAllocated(dbname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.dbname_.IsDefault()) { _impl_.dbname_.Set("", GetArenaForAllocation()); } #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() { _impl_.missing_ok_ = false; } inline bool DropdbStmt::_internal_missing_ok() const { return _impl_.missing_ok_; } inline bool DropdbStmt::missing_ok() const { // @@protoc_insertion_point(field_get:pg_query.DropdbStmt.missing_ok) return _internal_missing_ok(); } inline void DropdbStmt::_internal_set_missing_ok(bool value) { _impl_.missing_ok_ = value; } inline void DropdbStmt::set_missing_ok(bool value) { _internal_set_missing_ok(value); // @@protoc_insertion_point(field_set:pg_query.DropdbStmt.missing_ok) } // repeated .pg_query.Node options = 3 [json_name = "options"]; inline int DropdbStmt::_internal_options_size() const { return _impl_.options_.size(); } inline int DropdbStmt::options_size() const { return _internal_options_size(); } inline void DropdbStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* DropdbStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.DropdbStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* DropdbStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.DropdbStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& DropdbStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& DropdbStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.DropdbStmt.options) return _internal_options(index); } inline ::pg_query::Node* DropdbStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* DropdbStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.DropdbStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& DropdbStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.DropdbStmt.options) return _impl_.options_; } // ------------------------------------------------------------------- // VacuumStmt // repeated .pg_query.Node options = 1 [json_name = "options"]; inline int VacuumStmt::_internal_options_size() const { return _impl_.options_.size(); } inline int VacuumStmt::options_size() const { return _internal_options_size(); } inline void VacuumStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* VacuumStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.VacuumStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* VacuumStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.VacuumStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& VacuumStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& VacuumStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.VacuumStmt.options) return _internal_options(index); } inline ::pg_query::Node* VacuumStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* VacuumStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.VacuumStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& VacuumStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.VacuumStmt.options) return _impl_.options_; } // repeated .pg_query.Node rels = 2 [json_name = "rels"]; inline int VacuumStmt::_internal_rels_size() const { return _impl_.rels_.size(); } inline int VacuumStmt::rels_size() const { return _internal_rels_size(); } inline void VacuumStmt::clear_rels() { _impl_.rels_.Clear(); } inline ::pg_query::Node* VacuumStmt::mutable_rels(int index) { // @@protoc_insertion_point(field_mutable:pg_query.VacuumStmt.rels) return _impl_.rels_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* VacuumStmt::mutable_rels() { // @@protoc_insertion_point(field_mutable_list:pg_query.VacuumStmt.rels) return &_impl_.rels_; } inline const ::pg_query::Node& VacuumStmt::_internal_rels(int index) const { return _impl_.rels_.Get(index); } inline const ::pg_query::Node& VacuumStmt::rels(int index) const { // @@protoc_insertion_point(field_get:pg_query.VacuumStmt.rels) return _internal_rels(index); } inline ::pg_query::Node* VacuumStmt::_internal_add_rels() { return _impl_.rels_.Add(); } inline ::pg_query::Node* VacuumStmt::add_rels() { ::pg_query::Node* _add = _internal_add_rels(); // @@protoc_insertion_point(field_add:pg_query.VacuumStmt.rels) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& VacuumStmt::rels() const { // @@protoc_insertion_point(field_list:pg_query.VacuumStmt.rels) return _impl_.rels_; } // bool is_vacuumcmd = 3 [json_name = "is_vacuumcmd"]; inline void VacuumStmt::clear_is_vacuumcmd() { _impl_.is_vacuumcmd_ = false; } inline bool VacuumStmt::_internal_is_vacuumcmd() const { return _impl_.is_vacuumcmd_; } inline bool VacuumStmt::is_vacuumcmd() const { // @@protoc_insertion_point(field_get:pg_query.VacuumStmt.is_vacuumcmd) return _internal_is_vacuumcmd(); } inline void VacuumStmt::_internal_set_is_vacuumcmd(bool value) { _impl_.is_vacuumcmd_ = value; } inline void VacuumStmt::set_is_vacuumcmd(bool value) { _internal_set_is_vacuumcmd(value); // @@protoc_insertion_point(field_set:pg_query.VacuumStmt.is_vacuumcmd) } // ------------------------------------------------------------------- // ExplainStmt // .pg_query.Node query = 1 [json_name = "query"]; inline bool ExplainStmt::_internal_has_query() const { return this != internal_default_instance() && _impl_.query_ != nullptr; } inline bool ExplainStmt::has_query() const { return _internal_has_query(); } inline void ExplainStmt::clear_query() { if (GetArenaForAllocation() == nullptr && _impl_.query_ != nullptr) { delete _impl_.query_; } _impl_.query_ = nullptr; } inline const ::pg_query::Node& ExplainStmt::_internal_query() const { const ::pg_query::Node* p = _impl_.query_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& ExplainStmt::query() const { // @@protoc_insertion_point(field_get:pg_query.ExplainStmt.query) return _internal_query(); } inline void ExplainStmt::unsafe_arena_set_allocated_query( ::pg_query::Node* query) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.query_); } _impl_.query_ = query; if (query) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ExplainStmt.query) } inline ::pg_query::Node* ExplainStmt::release_query() { ::pg_query::Node* temp = _impl_.query_; _impl_.query_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* ExplainStmt::unsafe_arena_release_query() { // @@protoc_insertion_point(field_release:pg_query.ExplainStmt.query) ::pg_query::Node* temp = _impl_.query_; _impl_.query_ = nullptr; return temp; } inline ::pg_query::Node* ExplainStmt::_internal_mutable_query() { if (_impl_.query_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.query_ = p; } return _impl_.query_; } inline ::pg_query::Node* ExplainStmt::mutable_query() { ::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* query) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.query_; } if (query) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(query); if (message_arena != submessage_arena) { query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, query, submessage_arena); } } else { } _impl_.query_ = query; // @@protoc_insertion_point(field_set_allocated:pg_query.ExplainStmt.query) } // repeated .pg_query.Node options = 2 [json_name = "options"]; inline int ExplainStmt::_internal_options_size() const { return _impl_.options_.size(); } inline int ExplainStmt::options_size() const { return _internal_options_size(); } inline void ExplainStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* ExplainStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.ExplainStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* ExplainStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.ExplainStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& ExplainStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& ExplainStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.ExplainStmt.options) return _internal_options(index); } inline ::pg_query::Node* ExplainStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* ExplainStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.ExplainStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& ExplainStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.ExplainStmt.options) return _impl_.options_; } // ------------------------------------------------------------------- // CreateTableAsStmt // .pg_query.Node query = 1 [json_name = "query"]; inline bool CreateTableAsStmt::_internal_has_query() const { return this != internal_default_instance() && _impl_.query_ != nullptr; } inline bool CreateTableAsStmt::has_query() const { return _internal_has_query(); } inline void CreateTableAsStmt::clear_query() { if (GetArenaForAllocation() == nullptr && _impl_.query_ != nullptr) { delete _impl_.query_; } _impl_.query_ = nullptr; } inline const ::pg_query::Node& CreateTableAsStmt::_internal_query() const { const ::pg_query::Node* p = _impl_.query_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& CreateTableAsStmt::query() const { // @@protoc_insertion_point(field_get:pg_query.CreateTableAsStmt.query) return _internal_query(); } inline void CreateTableAsStmt::unsafe_arena_set_allocated_query( ::pg_query::Node* query) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.query_); } _impl_.query_ = query; if (query) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateTableAsStmt.query) } inline ::pg_query::Node* CreateTableAsStmt::release_query() { ::pg_query::Node* temp = _impl_.query_; _impl_.query_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* CreateTableAsStmt::unsafe_arena_release_query() { // @@protoc_insertion_point(field_release:pg_query.CreateTableAsStmt.query) ::pg_query::Node* temp = _impl_.query_; _impl_.query_ = nullptr; return temp; } inline ::pg_query::Node* CreateTableAsStmt::_internal_mutable_query() { if (_impl_.query_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.query_ = p; } return _impl_.query_; } inline ::pg_query::Node* CreateTableAsStmt::mutable_query() { ::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* query) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.query_; } if (query) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(query); if (message_arena != submessage_arena) { query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, query, submessage_arena); } } else { } _impl_.query_ = query; // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTableAsStmt.query) } // .pg_query.IntoClause into = 2 [json_name = "into"]; inline bool CreateTableAsStmt::_internal_has_into() const { return this != internal_default_instance() && _impl_.into_ != nullptr; } inline bool CreateTableAsStmt::has_into() const { return _internal_has_into(); } inline void CreateTableAsStmt::clear_into() { if (GetArenaForAllocation() == nullptr && _impl_.into_ != nullptr) { delete _impl_.into_; } _impl_.into_ = nullptr; } inline const ::pg_query::IntoClause& CreateTableAsStmt::_internal_into() const { const ::pg_query::IntoClause* p = _impl_.into_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_IntoClause_default_instance_); } inline const ::pg_query::IntoClause& CreateTableAsStmt::into() const { // @@protoc_insertion_point(field_get:pg_query.CreateTableAsStmt.into) return _internal_into(); } inline void CreateTableAsStmt::unsafe_arena_set_allocated_into( ::pg_query::IntoClause* into) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.into_); } _impl_.into_ = into; if (into) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateTableAsStmt.into) } inline ::pg_query::IntoClause* CreateTableAsStmt::release_into() { ::pg_query::IntoClause* temp = _impl_.into_; _impl_.into_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::IntoClause* CreateTableAsStmt::unsafe_arena_release_into() { // @@protoc_insertion_point(field_release:pg_query.CreateTableAsStmt.into) ::pg_query::IntoClause* temp = _impl_.into_; _impl_.into_ = nullptr; return temp; } inline ::pg_query::IntoClause* CreateTableAsStmt::_internal_mutable_into() { if (_impl_.into_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::IntoClause>(GetArenaForAllocation()); _impl_.into_ = p; } return _impl_.into_; } inline ::pg_query::IntoClause* CreateTableAsStmt::mutable_into() { ::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* into) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.into_; } if (into) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(into); if (message_arena != submessage_arena) { into = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, into, submessage_arena); } } else { } _impl_.into_ = into; // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTableAsStmt.into) } // .pg_query.ObjectType objtype = 3 [json_name = "objtype"]; inline void CreateTableAsStmt::clear_objtype() { _impl_.objtype_ = 0; } inline ::pg_query::ObjectType CreateTableAsStmt::_internal_objtype() const { return static_cast< ::pg_query::ObjectType >(_impl_.objtype_); } inline ::pg_query::ObjectType CreateTableAsStmt::objtype() const { // @@protoc_insertion_point(field_get:pg_query.CreateTableAsStmt.objtype) return _internal_objtype(); } inline void CreateTableAsStmt::_internal_set_objtype(::pg_query::ObjectType value) { _impl_.objtype_ = value; } inline void CreateTableAsStmt::set_objtype(::pg_query::ObjectType value) { _internal_set_objtype(value); // @@protoc_insertion_point(field_set:pg_query.CreateTableAsStmt.objtype) } // bool is_select_into = 4 [json_name = "is_select_into"]; inline void CreateTableAsStmt::clear_is_select_into() { _impl_.is_select_into_ = false; } inline bool CreateTableAsStmt::_internal_is_select_into() const { return _impl_.is_select_into_; } inline bool CreateTableAsStmt::is_select_into() const { // @@protoc_insertion_point(field_get:pg_query.CreateTableAsStmt.is_select_into) return _internal_is_select_into(); } inline void CreateTableAsStmt::_internal_set_is_select_into(bool value) { _impl_.is_select_into_ = value; } inline void CreateTableAsStmt::set_is_select_into(bool value) { _internal_set_is_select_into(value); // @@protoc_insertion_point(field_set:pg_query.CreateTableAsStmt.is_select_into) } // bool if_not_exists = 5 [json_name = "if_not_exists"]; inline void CreateTableAsStmt::clear_if_not_exists() { _impl_.if_not_exists_ = false; } inline bool CreateTableAsStmt::_internal_if_not_exists() const { return _impl_.if_not_exists_; } inline bool CreateTableAsStmt::if_not_exists() const { // @@protoc_insertion_point(field_get:pg_query.CreateTableAsStmt.if_not_exists) return _internal_if_not_exists(); } inline void CreateTableAsStmt::_internal_set_if_not_exists(bool value) { _impl_.if_not_exists_ = value; } inline void CreateTableAsStmt::set_if_not_exists(bool value) { _internal_set_if_not_exists(value); // @@protoc_insertion_point(field_set:pg_query.CreateTableAsStmt.if_not_exists) } // ------------------------------------------------------------------- // CreateSeqStmt // .pg_query.RangeVar sequence = 1 [json_name = "sequence"]; inline bool CreateSeqStmt::_internal_has_sequence() const { return this != internal_default_instance() && _impl_.sequence_ != nullptr; } inline bool CreateSeqStmt::has_sequence() const { return _internal_has_sequence(); } inline void CreateSeqStmt::clear_sequence() { if (GetArenaForAllocation() == nullptr && _impl_.sequence_ != nullptr) { delete _impl_.sequence_; } _impl_.sequence_ = nullptr; } inline const ::pg_query::RangeVar& CreateSeqStmt::_internal_sequence() const { const ::pg_query::RangeVar* p = _impl_.sequence_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& CreateSeqStmt::sequence() const { // @@protoc_insertion_point(field_get:pg_query.CreateSeqStmt.sequence) return _internal_sequence(); } inline void CreateSeqStmt::unsafe_arena_set_allocated_sequence( ::pg_query::RangeVar* sequence) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.sequence_); } _impl_.sequence_ = sequence; if (sequence) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateSeqStmt.sequence) } inline ::pg_query::RangeVar* CreateSeqStmt::release_sequence() { ::pg_query::RangeVar* temp = _impl_.sequence_; _impl_.sequence_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* CreateSeqStmt::unsafe_arena_release_sequence() { // @@protoc_insertion_point(field_release:pg_query.CreateSeqStmt.sequence) ::pg_query::RangeVar* temp = _impl_.sequence_; _impl_.sequence_ = nullptr; return temp; } inline ::pg_query::RangeVar* CreateSeqStmt::_internal_mutable_sequence() { if (_impl_.sequence_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.sequence_ = p; } return _impl_.sequence_; } inline ::pg_query::RangeVar* CreateSeqStmt::mutable_sequence() { ::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* sequence) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.sequence_; } if (sequence) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(sequence); if (message_arena != submessage_arena) { sequence = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, sequence, submessage_arena); } } else { } _impl_.sequence_ = sequence; // @@protoc_insertion_point(field_set_allocated:pg_query.CreateSeqStmt.sequence) } // repeated .pg_query.Node options = 2 [json_name = "options"]; inline int CreateSeqStmt::_internal_options_size() const { return _impl_.options_.size(); } inline int CreateSeqStmt::options_size() const { return _internal_options_size(); } inline void CreateSeqStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* CreateSeqStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateSeqStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateSeqStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateSeqStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& CreateSeqStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& CreateSeqStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateSeqStmt.options) return _internal_options(index); } inline ::pg_query::Node* CreateSeqStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* CreateSeqStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.CreateSeqStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateSeqStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.CreateSeqStmt.options) return _impl_.options_; } // uint32 owner_id = 3 [json_name = "ownerId"]; inline void CreateSeqStmt::clear_owner_id() { _impl_.owner_id_ = 0u; } inline uint32_t CreateSeqStmt::_internal_owner_id() const { return _impl_.owner_id_; } inline uint32_t CreateSeqStmt::owner_id() const { // @@protoc_insertion_point(field_get:pg_query.CreateSeqStmt.owner_id) return _internal_owner_id(); } inline void CreateSeqStmt::_internal_set_owner_id(uint32_t value) { _impl_.owner_id_ = value; } inline void CreateSeqStmt::set_owner_id(uint32_t value) { _internal_set_owner_id(value); // @@protoc_insertion_point(field_set:pg_query.CreateSeqStmt.owner_id) } // bool for_identity = 4 [json_name = "for_identity"]; inline void CreateSeqStmt::clear_for_identity() { _impl_.for_identity_ = false; } inline bool CreateSeqStmt::_internal_for_identity() const { return _impl_.for_identity_; } inline bool CreateSeqStmt::for_identity() const { // @@protoc_insertion_point(field_get:pg_query.CreateSeqStmt.for_identity) return _internal_for_identity(); } inline void CreateSeqStmt::_internal_set_for_identity(bool value) { _impl_.for_identity_ = value; } inline void CreateSeqStmt::set_for_identity(bool value) { _internal_set_for_identity(value); // @@protoc_insertion_point(field_set:pg_query.CreateSeqStmt.for_identity) } // bool if_not_exists = 5 [json_name = "if_not_exists"]; inline void CreateSeqStmt::clear_if_not_exists() { _impl_.if_not_exists_ = false; } inline bool CreateSeqStmt::_internal_if_not_exists() const { return _impl_.if_not_exists_; } inline bool CreateSeqStmt::if_not_exists() const { // @@protoc_insertion_point(field_get:pg_query.CreateSeqStmt.if_not_exists) return _internal_if_not_exists(); } inline void CreateSeqStmt::_internal_set_if_not_exists(bool value) { _impl_.if_not_exists_ = value; } inline void CreateSeqStmt::set_if_not_exists(bool value) { _internal_set_if_not_exists(value); // @@protoc_insertion_point(field_set:pg_query.CreateSeqStmt.if_not_exists) } // ------------------------------------------------------------------- // AlterSeqStmt // .pg_query.RangeVar sequence = 1 [json_name = "sequence"]; inline bool AlterSeqStmt::_internal_has_sequence() const { return this != internal_default_instance() && _impl_.sequence_ != nullptr; } inline bool AlterSeqStmt::has_sequence() const { return _internal_has_sequence(); } inline void AlterSeqStmt::clear_sequence() { if (GetArenaForAllocation() == nullptr && _impl_.sequence_ != nullptr) { delete _impl_.sequence_; } _impl_.sequence_ = nullptr; } inline const ::pg_query::RangeVar& AlterSeqStmt::_internal_sequence() const { const ::pg_query::RangeVar* p = _impl_.sequence_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& AlterSeqStmt::sequence() const { // @@protoc_insertion_point(field_get:pg_query.AlterSeqStmt.sequence) return _internal_sequence(); } inline void AlterSeqStmt::unsafe_arena_set_allocated_sequence( ::pg_query::RangeVar* sequence) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.sequence_); } _impl_.sequence_ = sequence; if (sequence) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterSeqStmt.sequence) } inline ::pg_query::RangeVar* AlterSeqStmt::release_sequence() { ::pg_query::RangeVar* temp = _impl_.sequence_; _impl_.sequence_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* AlterSeqStmt::unsafe_arena_release_sequence() { // @@protoc_insertion_point(field_release:pg_query.AlterSeqStmt.sequence) ::pg_query::RangeVar* temp = _impl_.sequence_; _impl_.sequence_ = nullptr; return temp; } inline ::pg_query::RangeVar* AlterSeqStmt::_internal_mutable_sequence() { if (_impl_.sequence_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.sequence_ = p; } return _impl_.sequence_; } inline ::pg_query::RangeVar* AlterSeqStmt::mutable_sequence() { ::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* sequence) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.sequence_; } if (sequence) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(sequence); if (message_arena != submessage_arena) { sequence = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, sequence, submessage_arena); } } else { } _impl_.sequence_ = sequence; // @@protoc_insertion_point(field_set_allocated:pg_query.AlterSeqStmt.sequence) } // repeated .pg_query.Node options = 2 [json_name = "options"]; inline int AlterSeqStmt::_internal_options_size() const { return _impl_.options_.size(); } inline int AlterSeqStmt::options_size() const { return _internal_options_size(); } inline void AlterSeqStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* AlterSeqStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterSeqStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterSeqStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterSeqStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& AlterSeqStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& AlterSeqStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterSeqStmt.options) return _internal_options(index); } inline ::pg_query::Node* AlterSeqStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* AlterSeqStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.AlterSeqStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterSeqStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.AlterSeqStmt.options) return _impl_.options_; } // bool for_identity = 3 [json_name = "for_identity"]; inline void AlterSeqStmt::clear_for_identity() { _impl_.for_identity_ = false; } inline bool AlterSeqStmt::_internal_for_identity() const { return _impl_.for_identity_; } inline bool AlterSeqStmt::for_identity() const { // @@protoc_insertion_point(field_get:pg_query.AlterSeqStmt.for_identity) return _internal_for_identity(); } inline void AlterSeqStmt::_internal_set_for_identity(bool value) { _impl_.for_identity_ = value; } inline void AlterSeqStmt::set_for_identity(bool value) { _internal_set_for_identity(value); // @@protoc_insertion_point(field_set:pg_query.AlterSeqStmt.for_identity) } // bool missing_ok = 4 [json_name = "missing_ok"]; inline void AlterSeqStmt::clear_missing_ok() { _impl_.missing_ok_ = false; } inline bool AlterSeqStmt::_internal_missing_ok() const { return _impl_.missing_ok_; } inline bool AlterSeqStmt::missing_ok() const { // @@protoc_insertion_point(field_get:pg_query.AlterSeqStmt.missing_ok) return _internal_missing_ok(); } inline void AlterSeqStmt::_internal_set_missing_ok(bool value) { _impl_.missing_ok_ = value; } inline void AlterSeqStmt::set_missing_ok(bool value) { _internal_set_missing_ok(value); // @@protoc_insertion_point(field_set:pg_query.AlterSeqStmt.missing_ok) } // ------------------------------------------------------------------- // VariableSetStmt // .pg_query.VariableSetKind kind = 1 [json_name = "kind"]; inline void VariableSetStmt::clear_kind() { _impl_.kind_ = 0; } inline ::pg_query::VariableSetKind VariableSetStmt::_internal_kind() const { return static_cast< ::pg_query::VariableSetKind >(_impl_.kind_); } inline ::pg_query::VariableSetKind VariableSetStmt::kind() const { // @@protoc_insertion_point(field_get:pg_query.VariableSetStmt.kind) return _internal_kind(); } inline void VariableSetStmt::_internal_set_kind(::pg_query::VariableSetKind value) { _impl_.kind_ = value; } inline void VariableSetStmt::set_kind(::pg_query::VariableSetKind value) { _internal_set_kind(value); // @@protoc_insertion_point(field_set:pg_query.VariableSetStmt.kind) } // string name = 2 [json_name = "name"]; inline void VariableSetStmt::clear_name() { _impl_.name_.ClearToEmpty(); } inline const std::string& VariableSetStmt::name() const { // @@protoc_insertion_point(field_get:pg_query.VariableSetStmt.name) return _internal_name(); } template inline PROTOBUF_ALWAYS_INLINE void VariableSetStmt::set_name(ArgT0&& arg0, ArgT... args) { _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.VariableSetStmt.name) } inline std::string* VariableSetStmt::mutable_name() { 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 { return _impl_.name_.Get(); } inline void VariableSetStmt::_internal_set_name(const std::string& value) { _impl_.name_.Set(value, GetArenaForAllocation()); } inline std::string* VariableSetStmt::_internal_mutable_name() { return _impl_.name_.Mutable(GetArenaForAllocation()); } inline std::string* VariableSetStmt::release_name() { // @@protoc_insertion_point(field_release:pg_query.VariableSetStmt.name) return _impl_.name_.Release(); } inline void VariableSetStmt::set_allocated_name(std::string* name) { if (name != nullptr) { } else { } _impl_.name_.SetAllocated(name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.name_.IsDefault()) { _impl_.name_.Set("", GetArenaForAllocation()); } #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 _impl_.args_.size(); } inline int VariableSetStmt::args_size() const { return _internal_args_size(); } inline void VariableSetStmt::clear_args() { _impl_.args_.Clear(); } inline ::pg_query::Node* VariableSetStmt::mutable_args(int index) { // @@protoc_insertion_point(field_mutable:pg_query.VariableSetStmt.args) return _impl_.args_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* VariableSetStmt::mutable_args() { // @@protoc_insertion_point(field_mutable_list:pg_query.VariableSetStmt.args) return &_impl_.args_; } inline const ::pg_query::Node& VariableSetStmt::_internal_args(int index) const { return _impl_.args_.Get(index); } inline const ::pg_query::Node& VariableSetStmt::args(int index) const { // @@protoc_insertion_point(field_get:pg_query.VariableSetStmt.args) return _internal_args(index); } inline ::pg_query::Node* VariableSetStmt::_internal_add_args() { return _impl_.args_.Add(); } inline ::pg_query::Node* VariableSetStmt::add_args() { ::pg_query::Node* _add = _internal_add_args(); // @@protoc_insertion_point(field_add:pg_query.VariableSetStmt.args) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& VariableSetStmt::args() const { // @@protoc_insertion_point(field_list:pg_query.VariableSetStmt.args) return _impl_.args_; } // bool is_local = 4 [json_name = "is_local"]; inline void VariableSetStmt::clear_is_local() { _impl_.is_local_ = false; } inline bool VariableSetStmt::_internal_is_local() const { return _impl_.is_local_; } inline bool VariableSetStmt::is_local() const { // @@protoc_insertion_point(field_get:pg_query.VariableSetStmt.is_local) return _internal_is_local(); } inline void VariableSetStmt::_internal_set_is_local(bool value) { _impl_.is_local_ = value; } inline void VariableSetStmt::set_is_local(bool value) { _internal_set_is_local(value); // @@protoc_insertion_point(field_set:pg_query.VariableSetStmt.is_local) } // ------------------------------------------------------------------- // VariableShowStmt // string name = 1 [json_name = "name"]; inline void VariableShowStmt::clear_name() { _impl_.name_.ClearToEmpty(); } inline const std::string& VariableShowStmt::name() const { // @@protoc_insertion_point(field_get:pg_query.VariableShowStmt.name) return _internal_name(); } template inline PROTOBUF_ALWAYS_INLINE void VariableShowStmt::set_name(ArgT0&& arg0, ArgT... args) { _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.VariableShowStmt.name) } inline std::string* VariableShowStmt::mutable_name() { 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 { return _impl_.name_.Get(); } inline void VariableShowStmt::_internal_set_name(const std::string& value) { _impl_.name_.Set(value, GetArenaForAllocation()); } inline std::string* VariableShowStmt::_internal_mutable_name() { return _impl_.name_.Mutable(GetArenaForAllocation()); } inline std::string* VariableShowStmt::release_name() { // @@protoc_insertion_point(field_release:pg_query.VariableShowStmt.name) return _impl_.name_.Release(); } inline void VariableShowStmt::set_allocated_name(std::string* name) { if (name != nullptr) { } else { } _impl_.name_.SetAllocated(name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.name_.IsDefault()) { _impl_.name_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:pg_query.VariableShowStmt.name) } // ------------------------------------------------------------------- // DiscardStmt // .pg_query.DiscardMode target = 1 [json_name = "target"]; inline void DiscardStmt::clear_target() { _impl_.target_ = 0; } inline ::pg_query::DiscardMode DiscardStmt::_internal_target() const { return static_cast< ::pg_query::DiscardMode >(_impl_.target_); } inline ::pg_query::DiscardMode DiscardStmt::target() const { // @@protoc_insertion_point(field_get:pg_query.DiscardStmt.target) return _internal_target(); } inline void DiscardStmt::_internal_set_target(::pg_query::DiscardMode value) { _impl_.target_ = value; } inline void DiscardStmt::set_target(::pg_query::DiscardMode value) { _internal_set_target(value); // @@protoc_insertion_point(field_set:pg_query.DiscardStmt.target) } // ------------------------------------------------------------------- // CreateTrigStmt // bool replace = 1 [json_name = "replace"]; inline void CreateTrigStmt::clear_replace() { _impl_.replace_ = false; } inline bool CreateTrigStmt::_internal_replace() const { return _impl_.replace_; } inline bool CreateTrigStmt::replace() const { // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.replace) return _internal_replace(); } inline void CreateTrigStmt::_internal_set_replace(bool value) { _impl_.replace_ = value; } inline void CreateTrigStmt::set_replace(bool value) { _internal_set_replace(value); // @@protoc_insertion_point(field_set:pg_query.CreateTrigStmt.replace) } // bool isconstraint = 2 [json_name = "isconstraint"]; inline void CreateTrigStmt::clear_isconstraint() { _impl_.isconstraint_ = false; } inline bool CreateTrigStmt::_internal_isconstraint() const { return _impl_.isconstraint_; } inline bool CreateTrigStmt::isconstraint() const { // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.isconstraint) return _internal_isconstraint(); } inline void CreateTrigStmt::_internal_set_isconstraint(bool value) { _impl_.isconstraint_ = value; } inline void CreateTrigStmt::set_isconstraint(bool value) { _internal_set_isconstraint(value); // @@protoc_insertion_point(field_set:pg_query.CreateTrigStmt.isconstraint) } // string trigname = 3 [json_name = "trigname"]; inline void CreateTrigStmt::clear_trigname() { _impl_.trigname_.ClearToEmpty(); } inline const std::string& CreateTrigStmt::trigname() const { // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.trigname) return _internal_trigname(); } template inline PROTOBUF_ALWAYS_INLINE void CreateTrigStmt::set_trigname(ArgT0&& arg0, ArgT... args) { _impl_.trigname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreateTrigStmt.trigname) } inline std::string* CreateTrigStmt::mutable_trigname() { 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 { return _impl_.trigname_.Get(); } inline void CreateTrigStmt::_internal_set_trigname(const std::string& value) { _impl_.trigname_.Set(value, GetArenaForAllocation()); } inline std::string* CreateTrigStmt::_internal_mutable_trigname() { return _impl_.trigname_.Mutable(GetArenaForAllocation()); } inline std::string* CreateTrigStmt::release_trigname() { // @@protoc_insertion_point(field_release:pg_query.CreateTrigStmt.trigname) return _impl_.trigname_.Release(); } inline void CreateTrigStmt::set_allocated_trigname(std::string* trigname) { if (trigname != nullptr) { } else { } _impl_.trigname_.SetAllocated(trigname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.trigname_.IsDefault()) { _impl_.trigname_.Set("", GetArenaForAllocation()); } #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::_internal_has_relation() const { return this != internal_default_instance() && _impl_.relation_ != nullptr; } inline bool CreateTrigStmt::has_relation() const { return _internal_has_relation(); } inline void CreateTrigStmt::clear_relation() { if (GetArenaForAllocation() == nullptr && _impl_.relation_ != nullptr) { delete _impl_.relation_; } _impl_.relation_ = nullptr; } inline const ::pg_query::RangeVar& CreateTrigStmt::_internal_relation() const { const ::pg_query::RangeVar* p = _impl_.relation_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& CreateTrigStmt::relation() const { // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.relation) return _internal_relation(); } inline void CreateTrigStmt::unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.relation_); } _impl_.relation_ = relation; if (relation) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateTrigStmt.relation) } inline ::pg_query::RangeVar* CreateTrigStmt::release_relation() { ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* CreateTrigStmt::unsafe_arena_release_relation() { // @@protoc_insertion_point(field_release:pg_query.CreateTrigStmt.relation) ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; return temp; } inline ::pg_query::RangeVar* CreateTrigStmt::_internal_mutable_relation() { if (_impl_.relation_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.relation_ = p; } return _impl_.relation_; } inline ::pg_query::RangeVar* CreateTrigStmt::mutable_relation() { ::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* relation) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.relation_; } if (relation) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(relation); if (message_arena != submessage_arena) { relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, relation, submessage_arena); } } else { } _impl_.relation_ = relation; // @@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 _impl_.funcname_.size(); } inline int CreateTrigStmt::funcname_size() const { return _internal_funcname_size(); } inline void CreateTrigStmt::clear_funcname() { _impl_.funcname_.Clear(); } inline ::pg_query::Node* CreateTrigStmt::mutable_funcname(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateTrigStmt.funcname) return _impl_.funcname_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateTrigStmt::mutable_funcname() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateTrigStmt.funcname) return &_impl_.funcname_; } inline const ::pg_query::Node& CreateTrigStmt::_internal_funcname(int index) const { return _impl_.funcname_.Get(index); } inline const ::pg_query::Node& CreateTrigStmt::funcname(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.funcname) return _internal_funcname(index); } inline ::pg_query::Node* CreateTrigStmt::_internal_add_funcname() { return _impl_.funcname_.Add(); } inline ::pg_query::Node* CreateTrigStmt::add_funcname() { ::pg_query::Node* _add = _internal_add_funcname(); // @@protoc_insertion_point(field_add:pg_query.CreateTrigStmt.funcname) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateTrigStmt::funcname() const { // @@protoc_insertion_point(field_list:pg_query.CreateTrigStmt.funcname) return _impl_.funcname_; } // repeated .pg_query.Node args = 6 [json_name = "args"]; inline int CreateTrigStmt::_internal_args_size() const { return _impl_.args_.size(); } inline int CreateTrigStmt::args_size() const { return _internal_args_size(); } inline void CreateTrigStmt::clear_args() { _impl_.args_.Clear(); } inline ::pg_query::Node* CreateTrigStmt::mutable_args(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateTrigStmt.args) return _impl_.args_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateTrigStmt::mutable_args() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateTrigStmt.args) return &_impl_.args_; } inline const ::pg_query::Node& CreateTrigStmt::_internal_args(int index) const { return _impl_.args_.Get(index); } inline const ::pg_query::Node& CreateTrigStmt::args(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.args) return _internal_args(index); } inline ::pg_query::Node* CreateTrigStmt::_internal_add_args() { return _impl_.args_.Add(); } inline ::pg_query::Node* CreateTrigStmt::add_args() { ::pg_query::Node* _add = _internal_add_args(); // @@protoc_insertion_point(field_add:pg_query.CreateTrigStmt.args) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateTrigStmt::args() const { // @@protoc_insertion_point(field_list:pg_query.CreateTrigStmt.args) return _impl_.args_; } // bool row = 7 [json_name = "row"]; inline void CreateTrigStmt::clear_row() { _impl_.row_ = false; } inline bool CreateTrigStmt::_internal_row() const { return _impl_.row_; } inline bool CreateTrigStmt::row() const { // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.row) return _internal_row(); } inline void CreateTrigStmt::_internal_set_row(bool value) { _impl_.row_ = value; } inline void CreateTrigStmt::set_row(bool value) { _internal_set_row(value); // @@protoc_insertion_point(field_set:pg_query.CreateTrigStmt.row) } // int32 timing = 8 [json_name = "timing"]; inline void CreateTrigStmt::clear_timing() { _impl_.timing_ = 0; } inline int32_t CreateTrigStmt::_internal_timing() const { return _impl_.timing_; } inline int32_t CreateTrigStmt::timing() const { // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.timing) return _internal_timing(); } inline void CreateTrigStmt::_internal_set_timing(int32_t value) { _impl_.timing_ = value; } inline void CreateTrigStmt::set_timing(int32_t value) { _internal_set_timing(value); // @@protoc_insertion_point(field_set:pg_query.CreateTrigStmt.timing) } // int32 events = 9 [json_name = "events"]; inline void CreateTrigStmt::clear_events() { _impl_.events_ = 0; } inline int32_t CreateTrigStmt::_internal_events() const { return _impl_.events_; } inline int32_t CreateTrigStmt::events() const { // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.events) return _internal_events(); } inline void CreateTrigStmt::_internal_set_events(int32_t value) { _impl_.events_ = value; } inline void CreateTrigStmt::set_events(int32_t value) { _internal_set_events(value); // @@protoc_insertion_point(field_set:pg_query.CreateTrigStmt.events) } // repeated .pg_query.Node columns = 10 [json_name = "columns"]; inline int CreateTrigStmt::_internal_columns_size() const { return _impl_.columns_.size(); } inline int CreateTrigStmt::columns_size() const { return _internal_columns_size(); } inline void CreateTrigStmt::clear_columns() { _impl_.columns_.Clear(); } inline ::pg_query::Node* CreateTrigStmt::mutable_columns(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateTrigStmt.columns) return _impl_.columns_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateTrigStmt::mutable_columns() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateTrigStmt.columns) return &_impl_.columns_; } inline const ::pg_query::Node& CreateTrigStmt::_internal_columns(int index) const { return _impl_.columns_.Get(index); } inline const ::pg_query::Node& CreateTrigStmt::columns(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.columns) return _internal_columns(index); } inline ::pg_query::Node* CreateTrigStmt::_internal_add_columns() { return _impl_.columns_.Add(); } inline ::pg_query::Node* CreateTrigStmt::add_columns() { ::pg_query::Node* _add = _internal_add_columns(); // @@protoc_insertion_point(field_add:pg_query.CreateTrigStmt.columns) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateTrigStmt::columns() const { // @@protoc_insertion_point(field_list:pg_query.CreateTrigStmt.columns) return _impl_.columns_; } // .pg_query.Node when_clause = 11 [json_name = "whenClause"]; inline bool CreateTrigStmt::_internal_has_when_clause() const { return this != internal_default_instance() && _impl_.when_clause_ != nullptr; } inline bool CreateTrigStmt::has_when_clause() const { return _internal_has_when_clause(); } inline void CreateTrigStmt::clear_when_clause() { if (GetArenaForAllocation() == nullptr && _impl_.when_clause_ != nullptr) { delete _impl_.when_clause_; } _impl_.when_clause_ = nullptr; } inline const ::pg_query::Node& CreateTrigStmt::_internal_when_clause() const { const ::pg_query::Node* p = _impl_.when_clause_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& CreateTrigStmt::when_clause() const { // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.when_clause) return _internal_when_clause(); } inline void CreateTrigStmt::unsafe_arena_set_allocated_when_clause( ::pg_query::Node* when_clause) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.when_clause_); } _impl_.when_clause_ = when_clause; if (when_clause) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateTrigStmt.when_clause) } inline ::pg_query::Node* CreateTrigStmt::release_when_clause() { ::pg_query::Node* temp = _impl_.when_clause_; _impl_.when_clause_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* CreateTrigStmt::unsafe_arena_release_when_clause() { // @@protoc_insertion_point(field_release:pg_query.CreateTrigStmt.when_clause) ::pg_query::Node* temp = _impl_.when_clause_; _impl_.when_clause_ = nullptr; return temp; } inline ::pg_query::Node* CreateTrigStmt::_internal_mutable_when_clause() { if (_impl_.when_clause_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.when_clause_ = p; } return _impl_.when_clause_; } inline ::pg_query::Node* CreateTrigStmt::mutable_when_clause() { ::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* when_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.when_clause_; } if (when_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(when_clause); if (message_arena != submessage_arena) { when_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, when_clause, submessage_arena); } } else { } _impl_.when_clause_ = when_clause; // @@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 _impl_.transition_rels_.size(); } inline int CreateTrigStmt::transition_rels_size() const { return _internal_transition_rels_size(); } inline void CreateTrigStmt::clear_transition_rels() { _impl_.transition_rels_.Clear(); } inline ::pg_query::Node* CreateTrigStmt::mutable_transition_rels(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateTrigStmt.transition_rels) return _impl_.transition_rels_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateTrigStmt::mutable_transition_rels() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateTrigStmt.transition_rels) return &_impl_.transition_rels_; } inline const ::pg_query::Node& CreateTrigStmt::_internal_transition_rels(int index) const { return _impl_.transition_rels_.Get(index); } inline const ::pg_query::Node& CreateTrigStmt::transition_rels(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.transition_rels) return _internal_transition_rels(index); } inline ::pg_query::Node* CreateTrigStmt::_internal_add_transition_rels() { return _impl_.transition_rels_.Add(); } inline ::pg_query::Node* CreateTrigStmt::add_transition_rels() { ::pg_query::Node* _add = _internal_add_transition_rels(); // @@protoc_insertion_point(field_add:pg_query.CreateTrigStmt.transition_rels) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateTrigStmt::transition_rels() const { // @@protoc_insertion_point(field_list:pg_query.CreateTrigStmt.transition_rels) return _impl_.transition_rels_; } // bool deferrable = 13 [json_name = "deferrable"]; inline void CreateTrigStmt::clear_deferrable() { _impl_.deferrable_ = false; } inline bool CreateTrigStmt::_internal_deferrable() const { return _impl_.deferrable_; } inline bool CreateTrigStmt::deferrable() const { // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.deferrable) return _internal_deferrable(); } inline void CreateTrigStmt::_internal_set_deferrable(bool value) { _impl_.deferrable_ = value; } inline void CreateTrigStmt::set_deferrable(bool value) { _internal_set_deferrable(value); // @@protoc_insertion_point(field_set:pg_query.CreateTrigStmt.deferrable) } // bool initdeferred = 14 [json_name = "initdeferred"]; inline void CreateTrigStmt::clear_initdeferred() { _impl_.initdeferred_ = false; } inline bool CreateTrigStmt::_internal_initdeferred() const { return _impl_.initdeferred_; } inline bool CreateTrigStmt::initdeferred() const { // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.initdeferred) return _internal_initdeferred(); } inline void CreateTrigStmt::_internal_set_initdeferred(bool value) { _impl_.initdeferred_ = value; } inline void CreateTrigStmt::set_initdeferred(bool value) { _internal_set_initdeferred(value); // @@protoc_insertion_point(field_set:pg_query.CreateTrigStmt.initdeferred) } // .pg_query.RangeVar constrrel = 15 [json_name = "constrrel"]; inline bool CreateTrigStmt::_internal_has_constrrel() const { return this != internal_default_instance() && _impl_.constrrel_ != nullptr; } inline bool CreateTrigStmt::has_constrrel() const { return _internal_has_constrrel(); } inline void CreateTrigStmt::clear_constrrel() { if (GetArenaForAllocation() == nullptr && _impl_.constrrel_ != nullptr) { delete _impl_.constrrel_; } _impl_.constrrel_ = nullptr; } inline const ::pg_query::RangeVar& CreateTrigStmt::_internal_constrrel() const { const ::pg_query::RangeVar* p = _impl_.constrrel_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& CreateTrigStmt::constrrel() const { // @@protoc_insertion_point(field_get:pg_query.CreateTrigStmt.constrrel) return _internal_constrrel(); } inline void CreateTrigStmt::unsafe_arena_set_allocated_constrrel( ::pg_query::RangeVar* constrrel) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.constrrel_); } _impl_.constrrel_ = constrrel; if (constrrel) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateTrigStmt.constrrel) } inline ::pg_query::RangeVar* CreateTrigStmt::release_constrrel() { ::pg_query::RangeVar* temp = _impl_.constrrel_; _impl_.constrrel_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* CreateTrigStmt::unsafe_arena_release_constrrel() { // @@protoc_insertion_point(field_release:pg_query.CreateTrigStmt.constrrel) ::pg_query::RangeVar* temp = _impl_.constrrel_; _impl_.constrrel_ = nullptr; return temp; } inline ::pg_query::RangeVar* CreateTrigStmt::_internal_mutable_constrrel() { if (_impl_.constrrel_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.constrrel_ = p; } return _impl_.constrrel_; } inline ::pg_query::RangeVar* CreateTrigStmt::mutable_constrrel() { ::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* constrrel) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.constrrel_; } if (constrrel) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(constrrel); if (message_arena != submessage_arena) { constrrel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, constrrel, submessage_arena); } } else { } _impl_.constrrel_ = constrrel; // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTrigStmt.constrrel) } // ------------------------------------------------------------------- // CreatePLangStmt // bool replace = 1 [json_name = "replace"]; inline void CreatePLangStmt::clear_replace() { _impl_.replace_ = false; } inline bool CreatePLangStmt::_internal_replace() const { return _impl_.replace_; } inline bool CreatePLangStmt::replace() const { // @@protoc_insertion_point(field_get:pg_query.CreatePLangStmt.replace) return _internal_replace(); } inline void CreatePLangStmt::_internal_set_replace(bool value) { _impl_.replace_ = value; } inline void CreatePLangStmt::set_replace(bool value) { _internal_set_replace(value); // @@protoc_insertion_point(field_set:pg_query.CreatePLangStmt.replace) } // string plname = 2 [json_name = "plname"]; inline void CreatePLangStmt::clear_plname() { _impl_.plname_.ClearToEmpty(); } inline const std::string& CreatePLangStmt::plname() const { // @@protoc_insertion_point(field_get:pg_query.CreatePLangStmt.plname) return _internal_plname(); } template inline PROTOBUF_ALWAYS_INLINE void CreatePLangStmt::set_plname(ArgT0&& arg0, ArgT... args) { _impl_.plname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreatePLangStmt.plname) } inline std::string* CreatePLangStmt::mutable_plname() { 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 { return _impl_.plname_.Get(); } inline void CreatePLangStmt::_internal_set_plname(const std::string& value) { _impl_.plname_.Set(value, GetArenaForAllocation()); } inline std::string* CreatePLangStmt::_internal_mutable_plname() { return _impl_.plname_.Mutable(GetArenaForAllocation()); } inline std::string* CreatePLangStmt::release_plname() { // @@protoc_insertion_point(field_release:pg_query.CreatePLangStmt.plname) return _impl_.plname_.Release(); } inline void CreatePLangStmt::set_allocated_plname(std::string* plname) { if (plname != nullptr) { } else { } _impl_.plname_.SetAllocated(plname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.plname_.IsDefault()) { _impl_.plname_.Set("", GetArenaForAllocation()); } #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 _impl_.plhandler_.size(); } inline int CreatePLangStmt::plhandler_size() const { return _internal_plhandler_size(); } inline void CreatePLangStmt::clear_plhandler() { _impl_.plhandler_.Clear(); } inline ::pg_query::Node* CreatePLangStmt::mutable_plhandler(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreatePLangStmt.plhandler) return _impl_.plhandler_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreatePLangStmt::mutable_plhandler() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreatePLangStmt.plhandler) return &_impl_.plhandler_; } inline const ::pg_query::Node& CreatePLangStmt::_internal_plhandler(int index) const { return _impl_.plhandler_.Get(index); } inline const ::pg_query::Node& CreatePLangStmt::plhandler(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreatePLangStmt.plhandler) return _internal_plhandler(index); } inline ::pg_query::Node* CreatePLangStmt::_internal_add_plhandler() { return _impl_.plhandler_.Add(); } inline ::pg_query::Node* CreatePLangStmt::add_plhandler() { ::pg_query::Node* _add = _internal_add_plhandler(); // @@protoc_insertion_point(field_add:pg_query.CreatePLangStmt.plhandler) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreatePLangStmt::plhandler() const { // @@protoc_insertion_point(field_list:pg_query.CreatePLangStmt.plhandler) return _impl_.plhandler_; } // repeated .pg_query.Node plinline = 4 [json_name = "plinline"]; inline int CreatePLangStmt::_internal_plinline_size() const { return _impl_.plinline_.size(); } inline int CreatePLangStmt::plinline_size() const { return _internal_plinline_size(); } inline void CreatePLangStmt::clear_plinline() { _impl_.plinline_.Clear(); } inline ::pg_query::Node* CreatePLangStmt::mutable_plinline(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreatePLangStmt.plinline) return _impl_.plinline_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreatePLangStmt::mutable_plinline() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreatePLangStmt.plinline) return &_impl_.plinline_; } inline const ::pg_query::Node& CreatePLangStmt::_internal_plinline(int index) const { return _impl_.plinline_.Get(index); } inline const ::pg_query::Node& CreatePLangStmt::plinline(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreatePLangStmt.plinline) return _internal_plinline(index); } inline ::pg_query::Node* CreatePLangStmt::_internal_add_plinline() { return _impl_.plinline_.Add(); } inline ::pg_query::Node* CreatePLangStmt::add_plinline() { ::pg_query::Node* _add = _internal_add_plinline(); // @@protoc_insertion_point(field_add:pg_query.CreatePLangStmt.plinline) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreatePLangStmt::plinline() const { // @@protoc_insertion_point(field_list:pg_query.CreatePLangStmt.plinline) return _impl_.plinline_; } // repeated .pg_query.Node plvalidator = 5 [json_name = "plvalidator"]; inline int CreatePLangStmt::_internal_plvalidator_size() const { return _impl_.plvalidator_.size(); } inline int CreatePLangStmt::plvalidator_size() const { return _internal_plvalidator_size(); } inline void CreatePLangStmt::clear_plvalidator() { _impl_.plvalidator_.Clear(); } inline ::pg_query::Node* CreatePLangStmt::mutable_plvalidator(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreatePLangStmt.plvalidator) return _impl_.plvalidator_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreatePLangStmt::mutable_plvalidator() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreatePLangStmt.plvalidator) return &_impl_.plvalidator_; } inline const ::pg_query::Node& CreatePLangStmt::_internal_plvalidator(int index) const { return _impl_.plvalidator_.Get(index); } inline const ::pg_query::Node& CreatePLangStmt::plvalidator(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreatePLangStmt.plvalidator) return _internal_plvalidator(index); } inline ::pg_query::Node* CreatePLangStmt::_internal_add_plvalidator() { return _impl_.plvalidator_.Add(); } inline ::pg_query::Node* CreatePLangStmt::add_plvalidator() { ::pg_query::Node* _add = _internal_add_plvalidator(); // @@protoc_insertion_point(field_add:pg_query.CreatePLangStmt.plvalidator) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreatePLangStmt::plvalidator() const { // @@protoc_insertion_point(field_list:pg_query.CreatePLangStmt.plvalidator) return _impl_.plvalidator_; } // bool pltrusted = 6 [json_name = "pltrusted"]; inline void CreatePLangStmt::clear_pltrusted() { _impl_.pltrusted_ = false; } inline bool CreatePLangStmt::_internal_pltrusted() const { return _impl_.pltrusted_; } inline bool CreatePLangStmt::pltrusted() const { // @@protoc_insertion_point(field_get:pg_query.CreatePLangStmt.pltrusted) return _internal_pltrusted(); } inline void CreatePLangStmt::_internal_set_pltrusted(bool value) { _impl_.pltrusted_ = value; } inline void CreatePLangStmt::set_pltrusted(bool value) { _internal_set_pltrusted(value); // @@protoc_insertion_point(field_set:pg_query.CreatePLangStmt.pltrusted) } // ------------------------------------------------------------------- // CreateRoleStmt // .pg_query.RoleStmtType stmt_type = 1 [json_name = "stmt_type"]; inline void CreateRoleStmt::clear_stmt_type() { _impl_.stmt_type_ = 0; } inline ::pg_query::RoleStmtType CreateRoleStmt::_internal_stmt_type() const { return static_cast< ::pg_query::RoleStmtType >(_impl_.stmt_type_); } inline ::pg_query::RoleStmtType CreateRoleStmt::stmt_type() const { // @@protoc_insertion_point(field_get:pg_query.CreateRoleStmt.stmt_type) return _internal_stmt_type(); } inline void CreateRoleStmt::_internal_set_stmt_type(::pg_query::RoleStmtType value) { _impl_.stmt_type_ = value; } inline void CreateRoleStmt::set_stmt_type(::pg_query::RoleStmtType value) { _internal_set_stmt_type(value); // @@protoc_insertion_point(field_set:pg_query.CreateRoleStmt.stmt_type) } // string role = 2 [json_name = "role"]; inline void CreateRoleStmt::clear_role() { _impl_.role_.ClearToEmpty(); } inline const std::string& CreateRoleStmt::role() const { // @@protoc_insertion_point(field_get:pg_query.CreateRoleStmt.role) return _internal_role(); } template inline PROTOBUF_ALWAYS_INLINE void CreateRoleStmt::set_role(ArgT0&& arg0, ArgT... args) { _impl_.role_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreateRoleStmt.role) } inline std::string* CreateRoleStmt::mutable_role() { 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 { return _impl_.role_.Get(); } inline void CreateRoleStmt::_internal_set_role(const std::string& value) { _impl_.role_.Set(value, GetArenaForAllocation()); } inline std::string* CreateRoleStmt::_internal_mutable_role() { return _impl_.role_.Mutable(GetArenaForAllocation()); } inline std::string* CreateRoleStmt::release_role() { // @@protoc_insertion_point(field_release:pg_query.CreateRoleStmt.role) return _impl_.role_.Release(); } inline void CreateRoleStmt::set_allocated_role(std::string* role) { if (role != nullptr) { } else { } _impl_.role_.SetAllocated(role, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.role_.IsDefault()) { _impl_.role_.Set("", GetArenaForAllocation()); } #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 _impl_.options_.size(); } inline int CreateRoleStmt::options_size() const { return _internal_options_size(); } inline void CreateRoleStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* CreateRoleStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateRoleStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateRoleStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateRoleStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& CreateRoleStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& CreateRoleStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateRoleStmt.options) return _internal_options(index); } inline ::pg_query::Node* CreateRoleStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* CreateRoleStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.CreateRoleStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateRoleStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.CreateRoleStmt.options) return _impl_.options_; } // ------------------------------------------------------------------- // AlterRoleStmt // .pg_query.RoleSpec role = 1 [json_name = "role"]; inline bool AlterRoleStmt::_internal_has_role() const { return this != internal_default_instance() && _impl_.role_ != nullptr; } inline bool AlterRoleStmt::has_role() const { return _internal_has_role(); } inline void AlterRoleStmt::clear_role() { if (GetArenaForAllocation() == nullptr && _impl_.role_ != nullptr) { delete _impl_.role_; } _impl_.role_ = nullptr; } inline const ::pg_query::RoleSpec& AlterRoleStmt::_internal_role() const { const ::pg_query::RoleSpec* p = _impl_.role_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RoleSpec_default_instance_); } inline const ::pg_query::RoleSpec& AlterRoleStmt::role() const { // @@protoc_insertion_point(field_get:pg_query.AlterRoleStmt.role) return _internal_role(); } inline void AlterRoleStmt::unsafe_arena_set_allocated_role( ::pg_query::RoleSpec* role) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.role_); } _impl_.role_ = role; if (role) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterRoleStmt.role) } inline ::pg_query::RoleSpec* AlterRoleStmt::release_role() { ::pg_query::RoleSpec* temp = _impl_.role_; _impl_.role_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RoleSpec* AlterRoleStmt::unsafe_arena_release_role() { // @@protoc_insertion_point(field_release:pg_query.AlterRoleStmt.role) ::pg_query::RoleSpec* temp = _impl_.role_; _impl_.role_ = nullptr; return temp; } inline ::pg_query::RoleSpec* AlterRoleStmt::_internal_mutable_role() { if (_impl_.role_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArenaForAllocation()); _impl_.role_ = p; } return _impl_.role_; } inline ::pg_query::RoleSpec* AlterRoleStmt::mutable_role() { ::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* role) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.role_; } if (role) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(role); if (message_arena != submessage_arena) { role = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, role, submessage_arena); } } else { } _impl_.role_ = role; // @@protoc_insertion_point(field_set_allocated:pg_query.AlterRoleStmt.role) } // repeated .pg_query.Node options = 2 [json_name = "options"]; inline int AlterRoleStmt::_internal_options_size() const { return _impl_.options_.size(); } inline int AlterRoleStmt::options_size() const { return _internal_options_size(); } inline void AlterRoleStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* AlterRoleStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterRoleStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterRoleStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterRoleStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& AlterRoleStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& AlterRoleStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterRoleStmt.options) return _internal_options(index); } inline ::pg_query::Node* AlterRoleStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* AlterRoleStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.AlterRoleStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterRoleStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.AlterRoleStmt.options) return _impl_.options_; } // int32 action = 3 [json_name = "action"]; inline void AlterRoleStmt::clear_action() { _impl_.action_ = 0; } inline int32_t AlterRoleStmt::_internal_action() const { return _impl_.action_; } inline int32_t AlterRoleStmt::action() const { // @@protoc_insertion_point(field_get:pg_query.AlterRoleStmt.action) return _internal_action(); } inline void AlterRoleStmt::_internal_set_action(int32_t value) { _impl_.action_ = value; } inline void AlterRoleStmt::set_action(int32_t value) { _internal_set_action(value); // @@protoc_insertion_point(field_set:pg_query.AlterRoleStmt.action) } // ------------------------------------------------------------------- // DropRoleStmt // repeated .pg_query.Node roles = 1 [json_name = "roles"]; inline int DropRoleStmt::_internal_roles_size() const { return _impl_.roles_.size(); } inline int DropRoleStmt::roles_size() const { return _internal_roles_size(); } inline void DropRoleStmt::clear_roles() { _impl_.roles_.Clear(); } inline ::pg_query::Node* DropRoleStmt::mutable_roles(int index) { // @@protoc_insertion_point(field_mutable:pg_query.DropRoleStmt.roles) return _impl_.roles_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* DropRoleStmt::mutable_roles() { // @@protoc_insertion_point(field_mutable_list:pg_query.DropRoleStmt.roles) return &_impl_.roles_; } inline const ::pg_query::Node& DropRoleStmt::_internal_roles(int index) const { return _impl_.roles_.Get(index); } inline const ::pg_query::Node& DropRoleStmt::roles(int index) const { // @@protoc_insertion_point(field_get:pg_query.DropRoleStmt.roles) return _internal_roles(index); } inline ::pg_query::Node* DropRoleStmt::_internal_add_roles() { return _impl_.roles_.Add(); } inline ::pg_query::Node* DropRoleStmt::add_roles() { ::pg_query::Node* _add = _internal_add_roles(); // @@protoc_insertion_point(field_add:pg_query.DropRoleStmt.roles) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& DropRoleStmt::roles() const { // @@protoc_insertion_point(field_list:pg_query.DropRoleStmt.roles) return _impl_.roles_; } // bool missing_ok = 2 [json_name = "missing_ok"]; inline void DropRoleStmt::clear_missing_ok() { _impl_.missing_ok_ = false; } inline bool DropRoleStmt::_internal_missing_ok() const { return _impl_.missing_ok_; } inline bool DropRoleStmt::missing_ok() const { // @@protoc_insertion_point(field_get:pg_query.DropRoleStmt.missing_ok) return _internal_missing_ok(); } inline void DropRoleStmt::_internal_set_missing_ok(bool value) { _impl_.missing_ok_ = value; } inline void DropRoleStmt::set_missing_ok(bool value) { _internal_set_missing_ok(value); // @@protoc_insertion_point(field_set:pg_query.DropRoleStmt.missing_ok) } // ------------------------------------------------------------------- // LockStmt // repeated .pg_query.Node relations = 1 [json_name = "relations"]; inline int LockStmt::_internal_relations_size() const { return _impl_.relations_.size(); } inline int LockStmt::relations_size() const { return _internal_relations_size(); } inline void LockStmt::clear_relations() { _impl_.relations_.Clear(); } inline ::pg_query::Node* LockStmt::mutable_relations(int index) { // @@protoc_insertion_point(field_mutable:pg_query.LockStmt.relations) return _impl_.relations_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* LockStmt::mutable_relations() { // @@protoc_insertion_point(field_mutable_list:pg_query.LockStmt.relations) return &_impl_.relations_; } inline const ::pg_query::Node& LockStmt::_internal_relations(int index) const { return _impl_.relations_.Get(index); } inline const ::pg_query::Node& LockStmt::relations(int index) const { // @@protoc_insertion_point(field_get:pg_query.LockStmt.relations) return _internal_relations(index); } inline ::pg_query::Node* LockStmt::_internal_add_relations() { return _impl_.relations_.Add(); } inline ::pg_query::Node* LockStmt::add_relations() { ::pg_query::Node* _add = _internal_add_relations(); // @@protoc_insertion_point(field_add:pg_query.LockStmt.relations) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& LockStmt::relations() const { // @@protoc_insertion_point(field_list:pg_query.LockStmt.relations) return _impl_.relations_; } // int32 mode = 2 [json_name = "mode"]; inline void LockStmt::clear_mode() { _impl_.mode_ = 0; } inline int32_t LockStmt::_internal_mode() const { return _impl_.mode_; } inline int32_t LockStmt::mode() const { // @@protoc_insertion_point(field_get:pg_query.LockStmt.mode) return _internal_mode(); } inline void LockStmt::_internal_set_mode(int32_t value) { _impl_.mode_ = value; } inline void LockStmt::set_mode(int32_t value) { _internal_set_mode(value); // @@protoc_insertion_point(field_set:pg_query.LockStmt.mode) } // bool nowait = 3 [json_name = "nowait"]; inline void LockStmt::clear_nowait() { _impl_.nowait_ = false; } inline bool LockStmt::_internal_nowait() const { return _impl_.nowait_; } inline bool LockStmt::nowait() const { // @@protoc_insertion_point(field_get:pg_query.LockStmt.nowait) return _internal_nowait(); } inline void LockStmt::_internal_set_nowait(bool value) { _impl_.nowait_ = value; } inline void LockStmt::set_nowait(bool value) { _internal_set_nowait(value); // @@protoc_insertion_point(field_set:pg_query.LockStmt.nowait) } // ------------------------------------------------------------------- // ConstraintsSetStmt // repeated .pg_query.Node constraints = 1 [json_name = "constraints"]; inline int ConstraintsSetStmt::_internal_constraints_size() const { return _impl_.constraints_.size(); } inline int ConstraintsSetStmt::constraints_size() const { return _internal_constraints_size(); } inline void ConstraintsSetStmt::clear_constraints() { _impl_.constraints_.Clear(); } inline ::pg_query::Node* ConstraintsSetStmt::mutable_constraints(int index) { // @@protoc_insertion_point(field_mutable:pg_query.ConstraintsSetStmt.constraints) return _impl_.constraints_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* ConstraintsSetStmt::mutable_constraints() { // @@protoc_insertion_point(field_mutable_list:pg_query.ConstraintsSetStmt.constraints) return &_impl_.constraints_; } inline const ::pg_query::Node& ConstraintsSetStmt::_internal_constraints(int index) const { return _impl_.constraints_.Get(index); } inline const ::pg_query::Node& ConstraintsSetStmt::constraints(int index) const { // @@protoc_insertion_point(field_get:pg_query.ConstraintsSetStmt.constraints) return _internal_constraints(index); } inline ::pg_query::Node* ConstraintsSetStmt::_internal_add_constraints() { return _impl_.constraints_.Add(); } inline ::pg_query::Node* ConstraintsSetStmt::add_constraints() { ::pg_query::Node* _add = _internal_add_constraints(); // @@protoc_insertion_point(field_add:pg_query.ConstraintsSetStmt.constraints) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& ConstraintsSetStmt::constraints() const { // @@protoc_insertion_point(field_list:pg_query.ConstraintsSetStmt.constraints) return _impl_.constraints_; } // bool deferred = 2 [json_name = "deferred"]; inline void ConstraintsSetStmt::clear_deferred() { _impl_.deferred_ = false; } inline bool ConstraintsSetStmt::_internal_deferred() const { return _impl_.deferred_; } inline bool ConstraintsSetStmt::deferred() const { // @@protoc_insertion_point(field_get:pg_query.ConstraintsSetStmt.deferred) return _internal_deferred(); } inline void ConstraintsSetStmt::_internal_set_deferred(bool value) { _impl_.deferred_ = value; } inline void ConstraintsSetStmt::set_deferred(bool value) { _internal_set_deferred(value); // @@protoc_insertion_point(field_set:pg_query.ConstraintsSetStmt.deferred) } // ------------------------------------------------------------------- // ReindexStmt // .pg_query.ReindexObjectType kind = 1 [json_name = "kind"]; inline void ReindexStmt::clear_kind() { _impl_.kind_ = 0; } inline ::pg_query::ReindexObjectType ReindexStmt::_internal_kind() const { return static_cast< ::pg_query::ReindexObjectType >(_impl_.kind_); } inline ::pg_query::ReindexObjectType ReindexStmt::kind() const { // @@protoc_insertion_point(field_get:pg_query.ReindexStmt.kind) return _internal_kind(); } inline void ReindexStmt::_internal_set_kind(::pg_query::ReindexObjectType value) { _impl_.kind_ = value; } inline void ReindexStmt::set_kind(::pg_query::ReindexObjectType value) { _internal_set_kind(value); // @@protoc_insertion_point(field_set:pg_query.ReindexStmt.kind) } // .pg_query.RangeVar relation = 2 [json_name = "relation"]; inline bool ReindexStmt::_internal_has_relation() const { return this != internal_default_instance() && _impl_.relation_ != nullptr; } inline bool ReindexStmt::has_relation() const { return _internal_has_relation(); } inline void ReindexStmt::clear_relation() { if (GetArenaForAllocation() == nullptr && _impl_.relation_ != nullptr) { delete _impl_.relation_; } _impl_.relation_ = nullptr; } inline const ::pg_query::RangeVar& ReindexStmt::_internal_relation() const { const ::pg_query::RangeVar* p = _impl_.relation_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& ReindexStmt::relation() const { // @@protoc_insertion_point(field_get:pg_query.ReindexStmt.relation) return _internal_relation(); } inline void ReindexStmt::unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.relation_); } _impl_.relation_ = relation; if (relation) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ReindexStmt.relation) } inline ::pg_query::RangeVar* ReindexStmt::release_relation() { ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* ReindexStmt::unsafe_arena_release_relation() { // @@protoc_insertion_point(field_release:pg_query.ReindexStmt.relation) ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; return temp; } inline ::pg_query::RangeVar* ReindexStmt::_internal_mutable_relation() { if (_impl_.relation_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.relation_ = p; } return _impl_.relation_; } inline ::pg_query::RangeVar* ReindexStmt::mutable_relation() { ::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* relation) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.relation_; } if (relation) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(relation); if (message_arena != submessage_arena) { relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, relation, submessage_arena); } } else { } _impl_.relation_ = relation; // @@protoc_insertion_point(field_set_allocated:pg_query.ReindexStmt.relation) } // string name = 3 [json_name = "name"]; inline void ReindexStmt::clear_name() { _impl_.name_.ClearToEmpty(); } inline const std::string& ReindexStmt::name() const { // @@protoc_insertion_point(field_get:pg_query.ReindexStmt.name) return _internal_name(); } template inline PROTOBUF_ALWAYS_INLINE void ReindexStmt::set_name(ArgT0&& arg0, ArgT... args) { _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.ReindexStmt.name) } inline std::string* ReindexStmt::mutable_name() { 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 { return _impl_.name_.Get(); } inline void ReindexStmt::_internal_set_name(const std::string& value) { _impl_.name_.Set(value, GetArenaForAllocation()); } inline std::string* ReindexStmt::_internal_mutable_name() { return _impl_.name_.Mutable(GetArenaForAllocation()); } inline std::string* ReindexStmt::release_name() { // @@protoc_insertion_point(field_release:pg_query.ReindexStmt.name) return _impl_.name_.Release(); } inline void ReindexStmt::set_allocated_name(std::string* name) { if (name != nullptr) { } else { } _impl_.name_.SetAllocated(name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.name_.IsDefault()) { _impl_.name_.Set("", GetArenaForAllocation()); } #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 _impl_.params_.size(); } inline int ReindexStmt::params_size() const { return _internal_params_size(); } inline void ReindexStmt::clear_params() { _impl_.params_.Clear(); } inline ::pg_query::Node* ReindexStmt::mutable_params(int index) { // @@protoc_insertion_point(field_mutable:pg_query.ReindexStmt.params) return _impl_.params_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* ReindexStmt::mutable_params() { // @@protoc_insertion_point(field_mutable_list:pg_query.ReindexStmt.params) return &_impl_.params_; } inline const ::pg_query::Node& ReindexStmt::_internal_params(int index) const { return _impl_.params_.Get(index); } inline const ::pg_query::Node& ReindexStmt::params(int index) const { // @@protoc_insertion_point(field_get:pg_query.ReindexStmt.params) return _internal_params(index); } inline ::pg_query::Node* ReindexStmt::_internal_add_params() { return _impl_.params_.Add(); } inline ::pg_query::Node* ReindexStmt::add_params() { ::pg_query::Node* _add = _internal_add_params(); // @@protoc_insertion_point(field_add:pg_query.ReindexStmt.params) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& ReindexStmt::params() const { // @@protoc_insertion_point(field_list:pg_query.ReindexStmt.params) return _impl_.params_; } // ------------------------------------------------------------------- // CheckPointStmt // ------------------------------------------------------------------- // CreateSchemaStmt // string schemaname = 1 [json_name = "schemaname"]; inline void CreateSchemaStmt::clear_schemaname() { _impl_.schemaname_.ClearToEmpty(); } inline const std::string& CreateSchemaStmt::schemaname() const { // @@protoc_insertion_point(field_get:pg_query.CreateSchemaStmt.schemaname) return _internal_schemaname(); } template inline PROTOBUF_ALWAYS_INLINE void CreateSchemaStmt::set_schemaname(ArgT0&& arg0, ArgT... args) { _impl_.schemaname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreateSchemaStmt.schemaname) } inline std::string* CreateSchemaStmt::mutable_schemaname() { 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 { return _impl_.schemaname_.Get(); } inline void CreateSchemaStmt::_internal_set_schemaname(const std::string& value) { _impl_.schemaname_.Set(value, GetArenaForAllocation()); } inline std::string* CreateSchemaStmt::_internal_mutable_schemaname() { return _impl_.schemaname_.Mutable(GetArenaForAllocation()); } inline std::string* CreateSchemaStmt::release_schemaname() { // @@protoc_insertion_point(field_release:pg_query.CreateSchemaStmt.schemaname) return _impl_.schemaname_.Release(); } inline void CreateSchemaStmt::set_allocated_schemaname(std::string* schemaname) { if (schemaname != nullptr) { } else { } _impl_.schemaname_.SetAllocated(schemaname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.schemaname_.IsDefault()) { _impl_.schemaname_.Set("", GetArenaForAllocation()); } #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::_internal_has_authrole() const { return this != internal_default_instance() && _impl_.authrole_ != nullptr; } inline bool CreateSchemaStmt::has_authrole() const { return _internal_has_authrole(); } inline void CreateSchemaStmt::clear_authrole() { if (GetArenaForAllocation() == nullptr && _impl_.authrole_ != nullptr) { delete _impl_.authrole_; } _impl_.authrole_ = nullptr; } inline const ::pg_query::RoleSpec& CreateSchemaStmt::_internal_authrole() const { const ::pg_query::RoleSpec* p = _impl_.authrole_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RoleSpec_default_instance_); } inline const ::pg_query::RoleSpec& CreateSchemaStmt::authrole() const { // @@protoc_insertion_point(field_get:pg_query.CreateSchemaStmt.authrole) return _internal_authrole(); } inline void CreateSchemaStmt::unsafe_arena_set_allocated_authrole( ::pg_query::RoleSpec* authrole) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.authrole_); } _impl_.authrole_ = authrole; if (authrole) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateSchemaStmt.authrole) } inline ::pg_query::RoleSpec* CreateSchemaStmt::release_authrole() { ::pg_query::RoleSpec* temp = _impl_.authrole_; _impl_.authrole_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RoleSpec* CreateSchemaStmt::unsafe_arena_release_authrole() { // @@protoc_insertion_point(field_release:pg_query.CreateSchemaStmt.authrole) ::pg_query::RoleSpec* temp = _impl_.authrole_; _impl_.authrole_ = nullptr; return temp; } inline ::pg_query::RoleSpec* CreateSchemaStmt::_internal_mutable_authrole() { if (_impl_.authrole_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArenaForAllocation()); _impl_.authrole_ = p; } return _impl_.authrole_; } inline ::pg_query::RoleSpec* CreateSchemaStmt::mutable_authrole() { ::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* authrole) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.authrole_; } if (authrole) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(authrole); if (message_arena != submessage_arena) { authrole = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, authrole, submessage_arena); } } else { } _impl_.authrole_ = authrole; // @@protoc_insertion_point(field_set_allocated:pg_query.CreateSchemaStmt.authrole) } // repeated .pg_query.Node schema_elts = 3 [json_name = "schemaElts"]; inline int CreateSchemaStmt::_internal_schema_elts_size() const { return _impl_.schema_elts_.size(); } inline int CreateSchemaStmt::schema_elts_size() const { return _internal_schema_elts_size(); } inline void CreateSchemaStmt::clear_schema_elts() { _impl_.schema_elts_.Clear(); } inline ::pg_query::Node* CreateSchemaStmt::mutable_schema_elts(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateSchemaStmt.schema_elts) return _impl_.schema_elts_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateSchemaStmt::mutable_schema_elts() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateSchemaStmt.schema_elts) return &_impl_.schema_elts_; } inline const ::pg_query::Node& CreateSchemaStmt::_internal_schema_elts(int index) const { return _impl_.schema_elts_.Get(index); } inline const ::pg_query::Node& CreateSchemaStmt::schema_elts(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateSchemaStmt.schema_elts) return _internal_schema_elts(index); } inline ::pg_query::Node* CreateSchemaStmt::_internal_add_schema_elts() { return _impl_.schema_elts_.Add(); } inline ::pg_query::Node* CreateSchemaStmt::add_schema_elts() { ::pg_query::Node* _add = _internal_add_schema_elts(); // @@protoc_insertion_point(field_add:pg_query.CreateSchemaStmt.schema_elts) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateSchemaStmt::schema_elts() const { // @@protoc_insertion_point(field_list:pg_query.CreateSchemaStmt.schema_elts) return _impl_.schema_elts_; } // bool if_not_exists = 4 [json_name = "if_not_exists"]; inline void CreateSchemaStmt::clear_if_not_exists() { _impl_.if_not_exists_ = false; } inline bool CreateSchemaStmt::_internal_if_not_exists() const { return _impl_.if_not_exists_; } inline bool CreateSchemaStmt::if_not_exists() const { // @@protoc_insertion_point(field_get:pg_query.CreateSchemaStmt.if_not_exists) return _internal_if_not_exists(); } inline void CreateSchemaStmt::_internal_set_if_not_exists(bool value) { _impl_.if_not_exists_ = value; } inline void CreateSchemaStmt::set_if_not_exists(bool value) { _internal_set_if_not_exists(value); // @@protoc_insertion_point(field_set:pg_query.CreateSchemaStmt.if_not_exists) } // ------------------------------------------------------------------- // AlterDatabaseStmt // string dbname = 1 [json_name = "dbname"]; inline void AlterDatabaseStmt::clear_dbname() { _impl_.dbname_.ClearToEmpty(); } inline const std::string& AlterDatabaseStmt::dbname() const { // @@protoc_insertion_point(field_get:pg_query.AlterDatabaseStmt.dbname) return _internal_dbname(); } template inline PROTOBUF_ALWAYS_INLINE void AlterDatabaseStmt::set_dbname(ArgT0&& arg0, ArgT... args) { _impl_.dbname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.AlterDatabaseStmt.dbname) } inline std::string* AlterDatabaseStmt::mutable_dbname() { 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 { return _impl_.dbname_.Get(); } inline void AlterDatabaseStmt::_internal_set_dbname(const std::string& value) { _impl_.dbname_.Set(value, GetArenaForAllocation()); } inline std::string* AlterDatabaseStmt::_internal_mutable_dbname() { return _impl_.dbname_.Mutable(GetArenaForAllocation()); } inline std::string* AlterDatabaseStmt::release_dbname() { // @@protoc_insertion_point(field_release:pg_query.AlterDatabaseStmt.dbname) return _impl_.dbname_.Release(); } inline void AlterDatabaseStmt::set_allocated_dbname(std::string* dbname) { if (dbname != nullptr) { } else { } _impl_.dbname_.SetAllocated(dbname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.dbname_.IsDefault()) { _impl_.dbname_.Set("", GetArenaForAllocation()); } #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 _impl_.options_.size(); } inline int AlterDatabaseStmt::options_size() const { return _internal_options_size(); } inline void AlterDatabaseStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* AlterDatabaseStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterDatabaseStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterDatabaseStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterDatabaseStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& AlterDatabaseStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& AlterDatabaseStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterDatabaseStmt.options) return _internal_options(index); } inline ::pg_query::Node* AlterDatabaseStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* AlterDatabaseStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.AlterDatabaseStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterDatabaseStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.AlterDatabaseStmt.options) return _impl_.options_; } // ------------------------------------------------------------------- // AlterDatabaseRefreshCollStmt // string dbname = 1 [json_name = "dbname"]; inline void AlterDatabaseRefreshCollStmt::clear_dbname() { _impl_.dbname_.ClearToEmpty(); } inline const std::string& AlterDatabaseRefreshCollStmt::dbname() const { // @@protoc_insertion_point(field_get:pg_query.AlterDatabaseRefreshCollStmt.dbname) return _internal_dbname(); } template inline PROTOBUF_ALWAYS_INLINE void AlterDatabaseRefreshCollStmt::set_dbname(ArgT0&& arg0, ArgT... args) { _impl_.dbname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.AlterDatabaseRefreshCollStmt.dbname) } inline std::string* AlterDatabaseRefreshCollStmt::mutable_dbname() { 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 { return _impl_.dbname_.Get(); } inline void AlterDatabaseRefreshCollStmt::_internal_set_dbname(const std::string& value) { _impl_.dbname_.Set(value, GetArenaForAllocation()); } inline std::string* AlterDatabaseRefreshCollStmt::_internal_mutable_dbname() { return _impl_.dbname_.Mutable(GetArenaForAllocation()); } inline std::string* AlterDatabaseRefreshCollStmt::release_dbname() { // @@protoc_insertion_point(field_release:pg_query.AlterDatabaseRefreshCollStmt.dbname) return _impl_.dbname_.Release(); } inline void AlterDatabaseRefreshCollStmt::set_allocated_dbname(std::string* dbname) { if (dbname != nullptr) { } else { } _impl_.dbname_.SetAllocated(dbname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.dbname_.IsDefault()) { _impl_.dbname_.Set("", GetArenaForAllocation()); } #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() { _impl_.dbname_.ClearToEmpty(); } inline const std::string& AlterDatabaseSetStmt::dbname() const { // @@protoc_insertion_point(field_get:pg_query.AlterDatabaseSetStmt.dbname) return _internal_dbname(); } template inline PROTOBUF_ALWAYS_INLINE void AlterDatabaseSetStmt::set_dbname(ArgT0&& arg0, ArgT... args) { _impl_.dbname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.AlterDatabaseSetStmt.dbname) } inline std::string* AlterDatabaseSetStmt::mutable_dbname() { 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 { return _impl_.dbname_.Get(); } inline void AlterDatabaseSetStmt::_internal_set_dbname(const std::string& value) { _impl_.dbname_.Set(value, GetArenaForAllocation()); } inline std::string* AlterDatabaseSetStmt::_internal_mutable_dbname() { return _impl_.dbname_.Mutable(GetArenaForAllocation()); } inline std::string* AlterDatabaseSetStmt::release_dbname() { // @@protoc_insertion_point(field_release:pg_query.AlterDatabaseSetStmt.dbname) return _impl_.dbname_.Release(); } inline void AlterDatabaseSetStmt::set_allocated_dbname(std::string* dbname) { if (dbname != nullptr) { } else { } _impl_.dbname_.SetAllocated(dbname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.dbname_.IsDefault()) { _impl_.dbname_.Set("", GetArenaForAllocation()); } #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::_internal_has_setstmt() const { return this != internal_default_instance() && _impl_.setstmt_ != nullptr; } inline bool AlterDatabaseSetStmt::has_setstmt() const { return _internal_has_setstmt(); } inline void AlterDatabaseSetStmt::clear_setstmt() { if (GetArenaForAllocation() == nullptr && _impl_.setstmt_ != nullptr) { delete _impl_.setstmt_; } _impl_.setstmt_ = nullptr; } inline const ::pg_query::VariableSetStmt& AlterDatabaseSetStmt::_internal_setstmt() const { const ::pg_query::VariableSetStmt* p = _impl_.setstmt_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_VariableSetStmt_default_instance_); } inline const ::pg_query::VariableSetStmt& AlterDatabaseSetStmt::setstmt() const { // @@protoc_insertion_point(field_get:pg_query.AlterDatabaseSetStmt.setstmt) return _internal_setstmt(); } inline void AlterDatabaseSetStmt::unsafe_arena_set_allocated_setstmt( ::pg_query::VariableSetStmt* setstmt) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.setstmt_); } _impl_.setstmt_ = setstmt; if (setstmt) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterDatabaseSetStmt.setstmt) } inline ::pg_query::VariableSetStmt* AlterDatabaseSetStmt::release_setstmt() { ::pg_query::VariableSetStmt* temp = _impl_.setstmt_; _impl_.setstmt_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::VariableSetStmt* AlterDatabaseSetStmt::unsafe_arena_release_setstmt() { // @@protoc_insertion_point(field_release:pg_query.AlterDatabaseSetStmt.setstmt) ::pg_query::VariableSetStmt* temp = _impl_.setstmt_; _impl_.setstmt_ = nullptr; return temp; } inline ::pg_query::VariableSetStmt* AlterDatabaseSetStmt::_internal_mutable_setstmt() { if (_impl_.setstmt_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::VariableSetStmt>(GetArenaForAllocation()); _impl_.setstmt_ = p; } return _impl_.setstmt_; } inline ::pg_query::VariableSetStmt* AlterDatabaseSetStmt::mutable_setstmt() { ::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* setstmt) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.setstmt_; } if (setstmt) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(setstmt); if (message_arena != submessage_arena) { setstmt = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, setstmt, submessage_arena); } } else { } _impl_.setstmt_ = setstmt; // @@protoc_insertion_point(field_set_allocated:pg_query.AlterDatabaseSetStmt.setstmt) } // ------------------------------------------------------------------- // AlterRoleSetStmt // .pg_query.RoleSpec role = 1 [json_name = "role"]; inline bool AlterRoleSetStmt::_internal_has_role() const { return this != internal_default_instance() && _impl_.role_ != nullptr; } inline bool AlterRoleSetStmt::has_role() const { return _internal_has_role(); } inline void AlterRoleSetStmt::clear_role() { if (GetArenaForAllocation() == nullptr && _impl_.role_ != nullptr) { delete _impl_.role_; } _impl_.role_ = nullptr; } inline const ::pg_query::RoleSpec& AlterRoleSetStmt::_internal_role() const { const ::pg_query::RoleSpec* p = _impl_.role_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RoleSpec_default_instance_); } inline const ::pg_query::RoleSpec& AlterRoleSetStmt::role() const { // @@protoc_insertion_point(field_get:pg_query.AlterRoleSetStmt.role) return _internal_role(); } inline void AlterRoleSetStmt::unsafe_arena_set_allocated_role( ::pg_query::RoleSpec* role) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.role_); } _impl_.role_ = role; if (role) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterRoleSetStmt.role) } inline ::pg_query::RoleSpec* AlterRoleSetStmt::release_role() { ::pg_query::RoleSpec* temp = _impl_.role_; _impl_.role_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RoleSpec* AlterRoleSetStmt::unsafe_arena_release_role() { // @@protoc_insertion_point(field_release:pg_query.AlterRoleSetStmt.role) ::pg_query::RoleSpec* temp = _impl_.role_; _impl_.role_ = nullptr; return temp; } inline ::pg_query::RoleSpec* AlterRoleSetStmt::_internal_mutable_role() { if (_impl_.role_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArenaForAllocation()); _impl_.role_ = p; } return _impl_.role_; } inline ::pg_query::RoleSpec* AlterRoleSetStmt::mutable_role() { ::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* role) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.role_; } if (role) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(role); if (message_arena != submessage_arena) { role = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, role, submessage_arena); } } else { } _impl_.role_ = role; // @@protoc_insertion_point(field_set_allocated:pg_query.AlterRoleSetStmt.role) } // string database = 2 [json_name = "database"]; inline void AlterRoleSetStmt::clear_database() { _impl_.database_.ClearToEmpty(); } inline const std::string& AlterRoleSetStmt::database() const { // @@protoc_insertion_point(field_get:pg_query.AlterRoleSetStmt.database) return _internal_database(); } template inline PROTOBUF_ALWAYS_INLINE void AlterRoleSetStmt::set_database(ArgT0&& arg0, ArgT... args) { _impl_.database_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.AlterRoleSetStmt.database) } inline std::string* AlterRoleSetStmt::mutable_database() { 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 { return _impl_.database_.Get(); } inline void AlterRoleSetStmt::_internal_set_database(const std::string& value) { _impl_.database_.Set(value, GetArenaForAllocation()); } inline std::string* AlterRoleSetStmt::_internal_mutable_database() { return _impl_.database_.Mutable(GetArenaForAllocation()); } inline std::string* AlterRoleSetStmt::release_database() { // @@protoc_insertion_point(field_release:pg_query.AlterRoleSetStmt.database) return _impl_.database_.Release(); } inline void AlterRoleSetStmt::set_allocated_database(std::string* database) { if (database != nullptr) { } else { } _impl_.database_.SetAllocated(database, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.database_.IsDefault()) { _impl_.database_.Set("", GetArenaForAllocation()); } #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::_internal_has_setstmt() const { return this != internal_default_instance() && _impl_.setstmt_ != nullptr; } inline bool AlterRoleSetStmt::has_setstmt() const { return _internal_has_setstmt(); } inline void AlterRoleSetStmt::clear_setstmt() { if (GetArenaForAllocation() == nullptr && _impl_.setstmt_ != nullptr) { delete _impl_.setstmt_; } _impl_.setstmt_ = nullptr; } inline const ::pg_query::VariableSetStmt& AlterRoleSetStmt::_internal_setstmt() const { const ::pg_query::VariableSetStmt* p = _impl_.setstmt_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_VariableSetStmt_default_instance_); } inline const ::pg_query::VariableSetStmt& AlterRoleSetStmt::setstmt() const { // @@protoc_insertion_point(field_get:pg_query.AlterRoleSetStmt.setstmt) return _internal_setstmt(); } inline void AlterRoleSetStmt::unsafe_arena_set_allocated_setstmt( ::pg_query::VariableSetStmt* setstmt) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.setstmt_); } _impl_.setstmt_ = setstmt; if (setstmt) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterRoleSetStmt.setstmt) } inline ::pg_query::VariableSetStmt* AlterRoleSetStmt::release_setstmt() { ::pg_query::VariableSetStmt* temp = _impl_.setstmt_; _impl_.setstmt_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::VariableSetStmt* AlterRoleSetStmt::unsafe_arena_release_setstmt() { // @@protoc_insertion_point(field_release:pg_query.AlterRoleSetStmt.setstmt) ::pg_query::VariableSetStmt* temp = _impl_.setstmt_; _impl_.setstmt_ = nullptr; return temp; } inline ::pg_query::VariableSetStmt* AlterRoleSetStmt::_internal_mutable_setstmt() { if (_impl_.setstmt_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::VariableSetStmt>(GetArenaForAllocation()); _impl_.setstmt_ = p; } return _impl_.setstmt_; } inline ::pg_query::VariableSetStmt* AlterRoleSetStmt::mutable_setstmt() { ::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* setstmt) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.setstmt_; } if (setstmt) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(setstmt); if (message_arena != submessage_arena) { setstmt = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, setstmt, submessage_arena); } } else { } _impl_.setstmt_ = setstmt; // @@protoc_insertion_point(field_set_allocated:pg_query.AlterRoleSetStmt.setstmt) } // ------------------------------------------------------------------- // CreateConversionStmt // repeated .pg_query.Node conversion_name = 1 [json_name = "conversion_name"]; inline int CreateConversionStmt::_internal_conversion_name_size() const { return _impl_.conversion_name_.size(); } inline int CreateConversionStmt::conversion_name_size() const { return _internal_conversion_name_size(); } inline void CreateConversionStmt::clear_conversion_name() { _impl_.conversion_name_.Clear(); } inline ::pg_query::Node* CreateConversionStmt::mutable_conversion_name(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateConversionStmt.conversion_name) return _impl_.conversion_name_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateConversionStmt::mutable_conversion_name() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateConversionStmt.conversion_name) return &_impl_.conversion_name_; } inline const ::pg_query::Node& CreateConversionStmt::_internal_conversion_name(int index) const { return _impl_.conversion_name_.Get(index); } inline const ::pg_query::Node& CreateConversionStmt::conversion_name(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateConversionStmt.conversion_name) return _internal_conversion_name(index); } inline ::pg_query::Node* CreateConversionStmt::_internal_add_conversion_name() { return _impl_.conversion_name_.Add(); } inline ::pg_query::Node* CreateConversionStmt::add_conversion_name() { ::pg_query::Node* _add = _internal_add_conversion_name(); // @@protoc_insertion_point(field_add:pg_query.CreateConversionStmt.conversion_name) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateConversionStmt::conversion_name() const { // @@protoc_insertion_point(field_list:pg_query.CreateConversionStmt.conversion_name) return _impl_.conversion_name_; } // string for_encoding_name = 2 [json_name = "for_encoding_name"]; inline void CreateConversionStmt::clear_for_encoding_name() { _impl_.for_encoding_name_.ClearToEmpty(); } inline const std::string& CreateConversionStmt::for_encoding_name() const { // @@protoc_insertion_point(field_get:pg_query.CreateConversionStmt.for_encoding_name) return _internal_for_encoding_name(); } template inline PROTOBUF_ALWAYS_INLINE void CreateConversionStmt::set_for_encoding_name(ArgT0&& arg0, ArgT... args) { _impl_.for_encoding_name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreateConversionStmt.for_encoding_name) } inline std::string* CreateConversionStmt::mutable_for_encoding_name() { 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 { return _impl_.for_encoding_name_.Get(); } inline void CreateConversionStmt::_internal_set_for_encoding_name(const std::string& value) { _impl_.for_encoding_name_.Set(value, GetArenaForAllocation()); } inline std::string* CreateConversionStmt::_internal_mutable_for_encoding_name() { return _impl_.for_encoding_name_.Mutable(GetArenaForAllocation()); } inline std::string* CreateConversionStmt::release_for_encoding_name() { // @@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* for_encoding_name) { if (for_encoding_name != nullptr) { } else { } _impl_.for_encoding_name_.SetAllocated(for_encoding_name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.for_encoding_name_.IsDefault()) { _impl_.for_encoding_name_.Set("", GetArenaForAllocation()); } #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() { _impl_.to_encoding_name_.ClearToEmpty(); } inline const std::string& CreateConversionStmt::to_encoding_name() const { // @@protoc_insertion_point(field_get:pg_query.CreateConversionStmt.to_encoding_name) return _internal_to_encoding_name(); } template inline PROTOBUF_ALWAYS_INLINE void CreateConversionStmt::set_to_encoding_name(ArgT0&& arg0, ArgT... args) { _impl_.to_encoding_name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreateConversionStmt.to_encoding_name) } inline std::string* CreateConversionStmt::mutable_to_encoding_name() { 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 { return _impl_.to_encoding_name_.Get(); } inline void CreateConversionStmt::_internal_set_to_encoding_name(const std::string& value) { _impl_.to_encoding_name_.Set(value, GetArenaForAllocation()); } inline std::string* CreateConversionStmt::_internal_mutable_to_encoding_name() { return _impl_.to_encoding_name_.Mutable(GetArenaForAllocation()); } inline std::string* CreateConversionStmt::release_to_encoding_name() { // @@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* to_encoding_name) { if (to_encoding_name != nullptr) { } else { } _impl_.to_encoding_name_.SetAllocated(to_encoding_name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.to_encoding_name_.IsDefault()) { _impl_.to_encoding_name_.Set("", GetArenaForAllocation()); } #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 _impl_.func_name_.size(); } inline int CreateConversionStmt::func_name_size() const { return _internal_func_name_size(); } inline void CreateConversionStmt::clear_func_name() { _impl_.func_name_.Clear(); } inline ::pg_query::Node* CreateConversionStmt::mutable_func_name(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateConversionStmt.func_name) return _impl_.func_name_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateConversionStmt::mutable_func_name() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateConversionStmt.func_name) return &_impl_.func_name_; } inline const ::pg_query::Node& CreateConversionStmt::_internal_func_name(int index) const { return _impl_.func_name_.Get(index); } inline const ::pg_query::Node& CreateConversionStmt::func_name(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateConversionStmt.func_name) return _internal_func_name(index); } inline ::pg_query::Node* CreateConversionStmt::_internal_add_func_name() { return _impl_.func_name_.Add(); } inline ::pg_query::Node* CreateConversionStmt::add_func_name() { ::pg_query::Node* _add = _internal_add_func_name(); // @@protoc_insertion_point(field_add:pg_query.CreateConversionStmt.func_name) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateConversionStmt::func_name() const { // @@protoc_insertion_point(field_list:pg_query.CreateConversionStmt.func_name) return _impl_.func_name_; } // bool def = 5 [json_name = "def"]; inline void CreateConversionStmt::clear_def() { _impl_.def_ = false; } inline bool CreateConversionStmt::_internal_def() const { return _impl_.def_; } inline bool CreateConversionStmt::def() const { // @@protoc_insertion_point(field_get:pg_query.CreateConversionStmt.def) return _internal_def(); } inline void CreateConversionStmt::_internal_set_def(bool value) { _impl_.def_ = value; } inline void CreateConversionStmt::set_def(bool value) { _internal_set_def(value); // @@protoc_insertion_point(field_set:pg_query.CreateConversionStmt.def) } // ------------------------------------------------------------------- // CreateCastStmt // .pg_query.TypeName sourcetype = 1 [json_name = "sourcetype"]; inline bool CreateCastStmt::_internal_has_sourcetype() const { return this != internal_default_instance() && _impl_.sourcetype_ != nullptr; } inline bool CreateCastStmt::has_sourcetype() const { return _internal_has_sourcetype(); } inline void CreateCastStmt::clear_sourcetype() { if (GetArenaForAllocation() == nullptr && _impl_.sourcetype_ != nullptr) { delete _impl_.sourcetype_; } _impl_.sourcetype_ = nullptr; } inline const ::pg_query::TypeName& CreateCastStmt::_internal_sourcetype() const { const ::pg_query::TypeName* p = _impl_.sourcetype_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_TypeName_default_instance_); } inline const ::pg_query::TypeName& CreateCastStmt::sourcetype() const { // @@protoc_insertion_point(field_get:pg_query.CreateCastStmt.sourcetype) return _internal_sourcetype(); } inline void CreateCastStmt::unsafe_arena_set_allocated_sourcetype( ::pg_query::TypeName* sourcetype) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.sourcetype_); } _impl_.sourcetype_ = sourcetype; if (sourcetype) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateCastStmt.sourcetype) } inline ::pg_query::TypeName* CreateCastStmt::release_sourcetype() { ::pg_query::TypeName* temp = _impl_.sourcetype_; _impl_.sourcetype_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::TypeName* CreateCastStmt::unsafe_arena_release_sourcetype() { // @@protoc_insertion_point(field_release:pg_query.CreateCastStmt.sourcetype) ::pg_query::TypeName* temp = _impl_.sourcetype_; _impl_.sourcetype_ = nullptr; return temp; } inline ::pg_query::TypeName* CreateCastStmt::_internal_mutable_sourcetype() { if (_impl_.sourcetype_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArenaForAllocation()); _impl_.sourcetype_ = p; } return _impl_.sourcetype_; } inline ::pg_query::TypeName* CreateCastStmt::mutable_sourcetype() { ::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* sourcetype) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.sourcetype_; } if (sourcetype) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(sourcetype); if (message_arena != submessage_arena) { sourcetype = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, sourcetype, submessage_arena); } } else { } _impl_.sourcetype_ = sourcetype; // @@protoc_insertion_point(field_set_allocated:pg_query.CreateCastStmt.sourcetype) } // .pg_query.TypeName targettype = 2 [json_name = "targettype"]; inline bool CreateCastStmt::_internal_has_targettype() const { return this != internal_default_instance() && _impl_.targettype_ != nullptr; } inline bool CreateCastStmt::has_targettype() const { return _internal_has_targettype(); } inline void CreateCastStmt::clear_targettype() { if (GetArenaForAllocation() == nullptr && _impl_.targettype_ != nullptr) { delete _impl_.targettype_; } _impl_.targettype_ = nullptr; } inline const ::pg_query::TypeName& CreateCastStmt::_internal_targettype() const { const ::pg_query::TypeName* p = _impl_.targettype_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_TypeName_default_instance_); } inline const ::pg_query::TypeName& CreateCastStmt::targettype() const { // @@protoc_insertion_point(field_get:pg_query.CreateCastStmt.targettype) return _internal_targettype(); } inline void CreateCastStmt::unsafe_arena_set_allocated_targettype( ::pg_query::TypeName* targettype) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.targettype_); } _impl_.targettype_ = targettype; if (targettype) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateCastStmt.targettype) } inline ::pg_query::TypeName* CreateCastStmt::release_targettype() { ::pg_query::TypeName* temp = _impl_.targettype_; _impl_.targettype_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::TypeName* CreateCastStmt::unsafe_arena_release_targettype() { // @@protoc_insertion_point(field_release:pg_query.CreateCastStmt.targettype) ::pg_query::TypeName* temp = _impl_.targettype_; _impl_.targettype_ = nullptr; return temp; } inline ::pg_query::TypeName* CreateCastStmt::_internal_mutable_targettype() { if (_impl_.targettype_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArenaForAllocation()); _impl_.targettype_ = p; } return _impl_.targettype_; } inline ::pg_query::TypeName* CreateCastStmt::mutable_targettype() { ::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* targettype) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.targettype_; } if (targettype) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(targettype); if (message_arena != submessage_arena) { targettype = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, targettype, submessage_arena); } } else { } _impl_.targettype_ = targettype; // @@protoc_insertion_point(field_set_allocated:pg_query.CreateCastStmt.targettype) } // .pg_query.ObjectWithArgs func = 3 [json_name = "func"]; inline bool CreateCastStmt::_internal_has_func() const { return this != internal_default_instance() && _impl_.func_ != nullptr; } inline bool CreateCastStmt::has_func() const { return _internal_has_func(); } inline void CreateCastStmt::clear_func() { if (GetArenaForAllocation() == nullptr && _impl_.func_ != nullptr) { delete _impl_.func_; } _impl_.func_ = nullptr; } inline const ::pg_query::ObjectWithArgs& CreateCastStmt::_internal_func() const { const ::pg_query::ObjectWithArgs* p = _impl_.func_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_ObjectWithArgs_default_instance_); } inline const ::pg_query::ObjectWithArgs& CreateCastStmt::func() const { // @@protoc_insertion_point(field_get:pg_query.CreateCastStmt.func) return _internal_func(); } inline void CreateCastStmt::unsafe_arena_set_allocated_func( ::pg_query::ObjectWithArgs* func) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.func_); } _impl_.func_ = func; if (func) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateCastStmt.func) } inline ::pg_query::ObjectWithArgs* CreateCastStmt::release_func() { ::pg_query::ObjectWithArgs* temp = _impl_.func_; _impl_.func_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::ObjectWithArgs* CreateCastStmt::unsafe_arena_release_func() { // @@protoc_insertion_point(field_release:pg_query.CreateCastStmt.func) ::pg_query::ObjectWithArgs* temp = _impl_.func_; _impl_.func_ = nullptr; return temp; } inline ::pg_query::ObjectWithArgs* CreateCastStmt::_internal_mutable_func() { if (_impl_.func_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::ObjectWithArgs>(GetArenaForAllocation()); _impl_.func_ = p; } return _impl_.func_; } inline ::pg_query::ObjectWithArgs* CreateCastStmt::mutable_func() { ::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* func) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.func_; } if (func) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(func); if (message_arena != submessage_arena) { func = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, func, submessage_arena); } } else { } _impl_.func_ = func; // @@protoc_insertion_point(field_set_allocated:pg_query.CreateCastStmt.func) } // .pg_query.CoercionContext context = 4 [json_name = "context"]; inline void CreateCastStmt::clear_context() { _impl_.context_ = 0; } inline ::pg_query::CoercionContext CreateCastStmt::_internal_context() const { return static_cast< ::pg_query::CoercionContext >(_impl_.context_); } inline ::pg_query::CoercionContext CreateCastStmt::context() const { // @@protoc_insertion_point(field_get:pg_query.CreateCastStmt.context) return _internal_context(); } inline void CreateCastStmt::_internal_set_context(::pg_query::CoercionContext value) { _impl_.context_ = value; } inline void CreateCastStmt::set_context(::pg_query::CoercionContext value) { _internal_set_context(value); // @@protoc_insertion_point(field_set:pg_query.CreateCastStmt.context) } // bool inout = 5 [json_name = "inout"]; inline void CreateCastStmt::clear_inout() { _impl_.inout_ = false; } inline bool CreateCastStmt::_internal_inout() const { return _impl_.inout_; } inline bool CreateCastStmt::inout() const { // @@protoc_insertion_point(field_get:pg_query.CreateCastStmt.inout) return _internal_inout(); } inline void CreateCastStmt::_internal_set_inout(bool value) { _impl_.inout_ = value; } inline void CreateCastStmt::set_inout(bool value) { _internal_set_inout(value); // @@protoc_insertion_point(field_set:pg_query.CreateCastStmt.inout) } // ------------------------------------------------------------------- // CreateOpClassStmt // repeated .pg_query.Node opclassname = 1 [json_name = "opclassname"]; inline int CreateOpClassStmt::_internal_opclassname_size() const { return _impl_.opclassname_.size(); } inline int CreateOpClassStmt::opclassname_size() const { return _internal_opclassname_size(); } inline void CreateOpClassStmt::clear_opclassname() { _impl_.opclassname_.Clear(); } inline ::pg_query::Node* CreateOpClassStmt::mutable_opclassname(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateOpClassStmt.opclassname) return _impl_.opclassname_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateOpClassStmt::mutable_opclassname() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateOpClassStmt.opclassname) return &_impl_.opclassname_; } inline const ::pg_query::Node& CreateOpClassStmt::_internal_opclassname(int index) const { return _impl_.opclassname_.Get(index); } inline const ::pg_query::Node& CreateOpClassStmt::opclassname(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateOpClassStmt.opclassname) return _internal_opclassname(index); } inline ::pg_query::Node* CreateOpClassStmt::_internal_add_opclassname() { return _impl_.opclassname_.Add(); } inline ::pg_query::Node* CreateOpClassStmt::add_opclassname() { ::pg_query::Node* _add = _internal_add_opclassname(); // @@protoc_insertion_point(field_add:pg_query.CreateOpClassStmt.opclassname) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateOpClassStmt::opclassname() const { // @@protoc_insertion_point(field_list:pg_query.CreateOpClassStmt.opclassname) return _impl_.opclassname_; } // repeated .pg_query.Node opfamilyname = 2 [json_name = "opfamilyname"]; inline int CreateOpClassStmt::_internal_opfamilyname_size() const { return _impl_.opfamilyname_.size(); } inline int CreateOpClassStmt::opfamilyname_size() const { return _internal_opfamilyname_size(); } inline void CreateOpClassStmt::clear_opfamilyname() { _impl_.opfamilyname_.Clear(); } inline ::pg_query::Node* CreateOpClassStmt::mutable_opfamilyname(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateOpClassStmt.opfamilyname) return _impl_.opfamilyname_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateOpClassStmt::mutable_opfamilyname() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateOpClassStmt.opfamilyname) return &_impl_.opfamilyname_; } inline const ::pg_query::Node& CreateOpClassStmt::_internal_opfamilyname(int index) const { return _impl_.opfamilyname_.Get(index); } inline const ::pg_query::Node& CreateOpClassStmt::opfamilyname(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateOpClassStmt.opfamilyname) return _internal_opfamilyname(index); } inline ::pg_query::Node* CreateOpClassStmt::_internal_add_opfamilyname() { return _impl_.opfamilyname_.Add(); } inline ::pg_query::Node* CreateOpClassStmt::add_opfamilyname() { ::pg_query::Node* _add = _internal_add_opfamilyname(); // @@protoc_insertion_point(field_add:pg_query.CreateOpClassStmt.opfamilyname) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateOpClassStmt::opfamilyname() const { // @@protoc_insertion_point(field_list:pg_query.CreateOpClassStmt.opfamilyname) return _impl_.opfamilyname_; } // string amname = 3 [json_name = "amname"]; inline void CreateOpClassStmt::clear_amname() { _impl_.amname_.ClearToEmpty(); } inline const std::string& CreateOpClassStmt::amname() const { // @@protoc_insertion_point(field_get:pg_query.CreateOpClassStmt.amname) return _internal_amname(); } template inline PROTOBUF_ALWAYS_INLINE void CreateOpClassStmt::set_amname(ArgT0&& arg0, ArgT... args) { _impl_.amname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreateOpClassStmt.amname) } inline std::string* CreateOpClassStmt::mutable_amname() { 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 { return _impl_.amname_.Get(); } inline void CreateOpClassStmt::_internal_set_amname(const std::string& value) { _impl_.amname_.Set(value, GetArenaForAllocation()); } inline std::string* CreateOpClassStmt::_internal_mutable_amname() { return _impl_.amname_.Mutable(GetArenaForAllocation()); } inline std::string* CreateOpClassStmt::release_amname() { // @@protoc_insertion_point(field_release:pg_query.CreateOpClassStmt.amname) return _impl_.amname_.Release(); } inline void CreateOpClassStmt::set_allocated_amname(std::string* amname) { if (amname != nullptr) { } else { } _impl_.amname_.SetAllocated(amname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.amname_.IsDefault()) { _impl_.amname_.Set("", GetArenaForAllocation()); } #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::_internal_has_datatype() const { return this != internal_default_instance() && _impl_.datatype_ != nullptr; } inline bool CreateOpClassStmt::has_datatype() const { return _internal_has_datatype(); } inline void CreateOpClassStmt::clear_datatype() { if (GetArenaForAllocation() == nullptr && _impl_.datatype_ != nullptr) { delete _impl_.datatype_; } _impl_.datatype_ = nullptr; } inline const ::pg_query::TypeName& CreateOpClassStmt::_internal_datatype() const { const ::pg_query::TypeName* p = _impl_.datatype_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_TypeName_default_instance_); } inline const ::pg_query::TypeName& CreateOpClassStmt::datatype() const { // @@protoc_insertion_point(field_get:pg_query.CreateOpClassStmt.datatype) return _internal_datatype(); } inline void CreateOpClassStmt::unsafe_arena_set_allocated_datatype( ::pg_query::TypeName* datatype) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.datatype_); } _impl_.datatype_ = datatype; if (datatype) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateOpClassStmt.datatype) } inline ::pg_query::TypeName* CreateOpClassStmt::release_datatype() { ::pg_query::TypeName* temp = _impl_.datatype_; _impl_.datatype_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::TypeName* CreateOpClassStmt::unsafe_arena_release_datatype() { // @@protoc_insertion_point(field_release:pg_query.CreateOpClassStmt.datatype) ::pg_query::TypeName* temp = _impl_.datatype_; _impl_.datatype_ = nullptr; return temp; } inline ::pg_query::TypeName* CreateOpClassStmt::_internal_mutable_datatype() { if (_impl_.datatype_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArenaForAllocation()); _impl_.datatype_ = p; } return _impl_.datatype_; } inline ::pg_query::TypeName* CreateOpClassStmt::mutable_datatype() { ::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* datatype) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.datatype_; } if (datatype) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(datatype); if (message_arena != submessage_arena) { datatype = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, datatype, submessage_arena); } } else { } _impl_.datatype_ = datatype; // @@protoc_insertion_point(field_set_allocated:pg_query.CreateOpClassStmt.datatype) } // repeated .pg_query.Node items = 5 [json_name = "items"]; inline int CreateOpClassStmt::_internal_items_size() const { return _impl_.items_.size(); } inline int CreateOpClassStmt::items_size() const { return _internal_items_size(); } inline void CreateOpClassStmt::clear_items() { _impl_.items_.Clear(); } inline ::pg_query::Node* CreateOpClassStmt::mutable_items(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateOpClassStmt.items) return _impl_.items_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateOpClassStmt::mutable_items() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateOpClassStmt.items) return &_impl_.items_; } inline const ::pg_query::Node& CreateOpClassStmt::_internal_items(int index) const { return _impl_.items_.Get(index); } inline const ::pg_query::Node& CreateOpClassStmt::items(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateOpClassStmt.items) return _internal_items(index); } inline ::pg_query::Node* CreateOpClassStmt::_internal_add_items() { return _impl_.items_.Add(); } inline ::pg_query::Node* CreateOpClassStmt::add_items() { ::pg_query::Node* _add = _internal_add_items(); // @@protoc_insertion_point(field_add:pg_query.CreateOpClassStmt.items) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateOpClassStmt::items() const { // @@protoc_insertion_point(field_list:pg_query.CreateOpClassStmt.items) return _impl_.items_; } // bool is_default = 6 [json_name = "isDefault"]; inline void CreateOpClassStmt::clear_is_default() { _impl_.is_default_ = false; } inline bool CreateOpClassStmt::_internal_is_default() const { return _impl_.is_default_; } inline bool CreateOpClassStmt::is_default() const { // @@protoc_insertion_point(field_get:pg_query.CreateOpClassStmt.is_default) return _internal_is_default(); } inline void CreateOpClassStmt::_internal_set_is_default(bool value) { _impl_.is_default_ = value; } inline void CreateOpClassStmt::set_is_default(bool value) { _internal_set_is_default(value); // @@protoc_insertion_point(field_set:pg_query.CreateOpClassStmt.is_default) } // ------------------------------------------------------------------- // CreateOpFamilyStmt // repeated .pg_query.Node opfamilyname = 1 [json_name = "opfamilyname"]; inline int CreateOpFamilyStmt::_internal_opfamilyname_size() const { return _impl_.opfamilyname_.size(); } inline int CreateOpFamilyStmt::opfamilyname_size() const { return _internal_opfamilyname_size(); } inline void CreateOpFamilyStmt::clear_opfamilyname() { _impl_.opfamilyname_.Clear(); } inline ::pg_query::Node* CreateOpFamilyStmt::mutable_opfamilyname(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateOpFamilyStmt.opfamilyname) return _impl_.opfamilyname_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateOpFamilyStmt::mutable_opfamilyname() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateOpFamilyStmt.opfamilyname) return &_impl_.opfamilyname_; } inline const ::pg_query::Node& CreateOpFamilyStmt::_internal_opfamilyname(int index) const { return _impl_.opfamilyname_.Get(index); } inline const ::pg_query::Node& CreateOpFamilyStmt::opfamilyname(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateOpFamilyStmt.opfamilyname) return _internal_opfamilyname(index); } inline ::pg_query::Node* CreateOpFamilyStmt::_internal_add_opfamilyname() { return _impl_.opfamilyname_.Add(); } inline ::pg_query::Node* CreateOpFamilyStmt::add_opfamilyname() { ::pg_query::Node* _add = _internal_add_opfamilyname(); // @@protoc_insertion_point(field_add:pg_query.CreateOpFamilyStmt.opfamilyname) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateOpFamilyStmt::opfamilyname() const { // @@protoc_insertion_point(field_list:pg_query.CreateOpFamilyStmt.opfamilyname) return _impl_.opfamilyname_; } // string amname = 2 [json_name = "amname"]; inline void CreateOpFamilyStmt::clear_amname() { _impl_.amname_.ClearToEmpty(); } inline const std::string& CreateOpFamilyStmt::amname() const { // @@protoc_insertion_point(field_get:pg_query.CreateOpFamilyStmt.amname) return _internal_amname(); } template inline PROTOBUF_ALWAYS_INLINE void CreateOpFamilyStmt::set_amname(ArgT0&& arg0, ArgT... args) { _impl_.amname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreateOpFamilyStmt.amname) } inline std::string* CreateOpFamilyStmt::mutable_amname() { 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 { return _impl_.amname_.Get(); } inline void CreateOpFamilyStmt::_internal_set_amname(const std::string& value) { _impl_.amname_.Set(value, GetArenaForAllocation()); } inline std::string* CreateOpFamilyStmt::_internal_mutable_amname() { return _impl_.amname_.Mutable(GetArenaForAllocation()); } inline std::string* CreateOpFamilyStmt::release_amname() { // @@protoc_insertion_point(field_release:pg_query.CreateOpFamilyStmt.amname) return _impl_.amname_.Release(); } inline void CreateOpFamilyStmt::set_allocated_amname(std::string* amname) { if (amname != nullptr) { } else { } _impl_.amname_.SetAllocated(amname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.amname_.IsDefault()) { _impl_.amname_.Set("", GetArenaForAllocation()); } #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 _impl_.opfamilyname_.size(); } inline int AlterOpFamilyStmt::opfamilyname_size() const { return _internal_opfamilyname_size(); } inline void AlterOpFamilyStmt::clear_opfamilyname() { _impl_.opfamilyname_.Clear(); } inline ::pg_query::Node* AlterOpFamilyStmt::mutable_opfamilyname(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterOpFamilyStmt.opfamilyname) return _impl_.opfamilyname_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterOpFamilyStmt::mutable_opfamilyname() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterOpFamilyStmt.opfamilyname) return &_impl_.opfamilyname_; } inline const ::pg_query::Node& AlterOpFamilyStmt::_internal_opfamilyname(int index) const { return _impl_.opfamilyname_.Get(index); } inline const ::pg_query::Node& AlterOpFamilyStmt::opfamilyname(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterOpFamilyStmt.opfamilyname) return _internal_opfamilyname(index); } inline ::pg_query::Node* AlterOpFamilyStmt::_internal_add_opfamilyname() { return _impl_.opfamilyname_.Add(); } inline ::pg_query::Node* AlterOpFamilyStmt::add_opfamilyname() { ::pg_query::Node* _add = _internal_add_opfamilyname(); // @@protoc_insertion_point(field_add:pg_query.AlterOpFamilyStmt.opfamilyname) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterOpFamilyStmt::opfamilyname() const { // @@protoc_insertion_point(field_list:pg_query.AlterOpFamilyStmt.opfamilyname) return _impl_.opfamilyname_; } // string amname = 2 [json_name = "amname"]; inline void AlterOpFamilyStmt::clear_amname() { _impl_.amname_.ClearToEmpty(); } inline const std::string& AlterOpFamilyStmt::amname() const { // @@protoc_insertion_point(field_get:pg_query.AlterOpFamilyStmt.amname) return _internal_amname(); } template inline PROTOBUF_ALWAYS_INLINE void AlterOpFamilyStmt::set_amname(ArgT0&& arg0, ArgT... args) { _impl_.amname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.AlterOpFamilyStmt.amname) } inline std::string* AlterOpFamilyStmt::mutable_amname() { 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 { return _impl_.amname_.Get(); } inline void AlterOpFamilyStmt::_internal_set_amname(const std::string& value) { _impl_.amname_.Set(value, GetArenaForAllocation()); } inline std::string* AlterOpFamilyStmt::_internal_mutable_amname() { return _impl_.amname_.Mutable(GetArenaForAllocation()); } inline std::string* AlterOpFamilyStmt::release_amname() { // @@protoc_insertion_point(field_release:pg_query.AlterOpFamilyStmt.amname) return _impl_.amname_.Release(); } inline void AlterOpFamilyStmt::set_allocated_amname(std::string* amname) { if (amname != nullptr) { } else { } _impl_.amname_.SetAllocated(amname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.amname_.IsDefault()) { _impl_.amname_.Set("", GetArenaForAllocation()); } #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() { _impl_.is_drop_ = false; } inline bool AlterOpFamilyStmt::_internal_is_drop() const { return _impl_.is_drop_; } inline bool AlterOpFamilyStmt::is_drop() const { // @@protoc_insertion_point(field_get:pg_query.AlterOpFamilyStmt.is_drop) return _internal_is_drop(); } inline void AlterOpFamilyStmt::_internal_set_is_drop(bool value) { _impl_.is_drop_ = value; } inline void AlterOpFamilyStmt::set_is_drop(bool value) { _internal_set_is_drop(value); // @@protoc_insertion_point(field_set:pg_query.AlterOpFamilyStmt.is_drop) } // repeated .pg_query.Node items = 4 [json_name = "items"]; inline int AlterOpFamilyStmt::_internal_items_size() const { return _impl_.items_.size(); } inline int AlterOpFamilyStmt::items_size() const { return _internal_items_size(); } inline void AlterOpFamilyStmt::clear_items() { _impl_.items_.Clear(); } inline ::pg_query::Node* AlterOpFamilyStmt::mutable_items(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterOpFamilyStmt.items) return _impl_.items_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterOpFamilyStmt::mutable_items() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterOpFamilyStmt.items) return &_impl_.items_; } inline const ::pg_query::Node& AlterOpFamilyStmt::_internal_items(int index) const { return _impl_.items_.Get(index); } inline const ::pg_query::Node& AlterOpFamilyStmt::items(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterOpFamilyStmt.items) return _internal_items(index); } inline ::pg_query::Node* AlterOpFamilyStmt::_internal_add_items() { return _impl_.items_.Add(); } inline ::pg_query::Node* AlterOpFamilyStmt::add_items() { ::pg_query::Node* _add = _internal_add_items(); // @@protoc_insertion_point(field_add:pg_query.AlterOpFamilyStmt.items) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterOpFamilyStmt::items() const { // @@protoc_insertion_point(field_list:pg_query.AlterOpFamilyStmt.items) return _impl_.items_; } // ------------------------------------------------------------------- // PrepareStmt // string name = 1 [json_name = "name"]; inline void PrepareStmt::clear_name() { _impl_.name_.ClearToEmpty(); } inline const std::string& PrepareStmt::name() const { // @@protoc_insertion_point(field_get:pg_query.PrepareStmt.name) return _internal_name(); } template inline PROTOBUF_ALWAYS_INLINE void PrepareStmt::set_name(ArgT0&& arg0, ArgT... args) { _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.PrepareStmt.name) } inline std::string* PrepareStmt::mutable_name() { 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 { return _impl_.name_.Get(); } inline void PrepareStmt::_internal_set_name(const std::string& value) { _impl_.name_.Set(value, GetArenaForAllocation()); } inline std::string* PrepareStmt::_internal_mutable_name() { return _impl_.name_.Mutable(GetArenaForAllocation()); } inline std::string* PrepareStmt::release_name() { // @@protoc_insertion_point(field_release:pg_query.PrepareStmt.name) return _impl_.name_.Release(); } inline void PrepareStmt::set_allocated_name(std::string* name) { if (name != nullptr) { } else { } _impl_.name_.SetAllocated(name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.name_.IsDefault()) { _impl_.name_.Set("", GetArenaForAllocation()); } #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 _impl_.argtypes_.size(); } inline int PrepareStmt::argtypes_size() const { return _internal_argtypes_size(); } inline void PrepareStmt::clear_argtypes() { _impl_.argtypes_.Clear(); } inline ::pg_query::Node* PrepareStmt::mutable_argtypes(int index) { // @@protoc_insertion_point(field_mutable:pg_query.PrepareStmt.argtypes) return _impl_.argtypes_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* PrepareStmt::mutable_argtypes() { // @@protoc_insertion_point(field_mutable_list:pg_query.PrepareStmt.argtypes) return &_impl_.argtypes_; } inline const ::pg_query::Node& PrepareStmt::_internal_argtypes(int index) const { return _impl_.argtypes_.Get(index); } inline const ::pg_query::Node& PrepareStmt::argtypes(int index) const { // @@protoc_insertion_point(field_get:pg_query.PrepareStmt.argtypes) return _internal_argtypes(index); } inline ::pg_query::Node* PrepareStmt::_internal_add_argtypes() { return _impl_.argtypes_.Add(); } inline ::pg_query::Node* PrepareStmt::add_argtypes() { ::pg_query::Node* _add = _internal_add_argtypes(); // @@protoc_insertion_point(field_add:pg_query.PrepareStmt.argtypes) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& PrepareStmt::argtypes() const { // @@protoc_insertion_point(field_list:pg_query.PrepareStmt.argtypes) return _impl_.argtypes_; } // .pg_query.Node query = 3 [json_name = "query"]; inline bool PrepareStmt::_internal_has_query() const { return this != internal_default_instance() && _impl_.query_ != nullptr; } inline bool PrepareStmt::has_query() const { return _internal_has_query(); } inline void PrepareStmt::clear_query() { if (GetArenaForAllocation() == nullptr && _impl_.query_ != nullptr) { delete _impl_.query_; } _impl_.query_ = nullptr; } inline const ::pg_query::Node& PrepareStmt::_internal_query() const { const ::pg_query::Node* p = _impl_.query_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& PrepareStmt::query() const { // @@protoc_insertion_point(field_get:pg_query.PrepareStmt.query) return _internal_query(); } inline void PrepareStmt::unsafe_arena_set_allocated_query( ::pg_query::Node* query) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.query_); } _impl_.query_ = query; if (query) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.PrepareStmt.query) } inline ::pg_query::Node* PrepareStmt::release_query() { ::pg_query::Node* temp = _impl_.query_; _impl_.query_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* PrepareStmt::unsafe_arena_release_query() { // @@protoc_insertion_point(field_release:pg_query.PrepareStmt.query) ::pg_query::Node* temp = _impl_.query_; _impl_.query_ = nullptr; return temp; } inline ::pg_query::Node* PrepareStmt::_internal_mutable_query() { if (_impl_.query_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.query_ = p; } return _impl_.query_; } inline ::pg_query::Node* PrepareStmt::mutable_query() { ::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* query) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.query_; } if (query) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(query); if (message_arena != submessage_arena) { query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, query, submessage_arena); } } else { } _impl_.query_ = query; // @@protoc_insertion_point(field_set_allocated:pg_query.PrepareStmt.query) } // ------------------------------------------------------------------- // ExecuteStmt // string name = 1 [json_name = "name"]; inline void ExecuteStmt::clear_name() { _impl_.name_.ClearToEmpty(); } inline const std::string& ExecuteStmt::name() const { // @@protoc_insertion_point(field_get:pg_query.ExecuteStmt.name) return _internal_name(); } template inline PROTOBUF_ALWAYS_INLINE void ExecuteStmt::set_name(ArgT0&& arg0, ArgT... args) { _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.ExecuteStmt.name) } inline std::string* ExecuteStmt::mutable_name() { 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 { return _impl_.name_.Get(); } inline void ExecuteStmt::_internal_set_name(const std::string& value) { _impl_.name_.Set(value, GetArenaForAllocation()); } inline std::string* ExecuteStmt::_internal_mutable_name() { return _impl_.name_.Mutable(GetArenaForAllocation()); } inline std::string* ExecuteStmt::release_name() { // @@protoc_insertion_point(field_release:pg_query.ExecuteStmt.name) return _impl_.name_.Release(); } inline void ExecuteStmt::set_allocated_name(std::string* name) { if (name != nullptr) { } else { } _impl_.name_.SetAllocated(name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.name_.IsDefault()) { _impl_.name_.Set("", GetArenaForAllocation()); } #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 _impl_.params_.size(); } inline int ExecuteStmt::params_size() const { return _internal_params_size(); } inline void ExecuteStmt::clear_params() { _impl_.params_.Clear(); } inline ::pg_query::Node* ExecuteStmt::mutable_params(int index) { // @@protoc_insertion_point(field_mutable:pg_query.ExecuteStmt.params) return _impl_.params_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* ExecuteStmt::mutable_params() { // @@protoc_insertion_point(field_mutable_list:pg_query.ExecuteStmt.params) return &_impl_.params_; } inline const ::pg_query::Node& ExecuteStmt::_internal_params(int index) const { return _impl_.params_.Get(index); } inline const ::pg_query::Node& ExecuteStmt::params(int index) const { // @@protoc_insertion_point(field_get:pg_query.ExecuteStmt.params) return _internal_params(index); } inline ::pg_query::Node* ExecuteStmt::_internal_add_params() { return _impl_.params_.Add(); } inline ::pg_query::Node* ExecuteStmt::add_params() { ::pg_query::Node* _add = _internal_add_params(); // @@protoc_insertion_point(field_add:pg_query.ExecuteStmt.params) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& ExecuteStmt::params() const { // @@protoc_insertion_point(field_list:pg_query.ExecuteStmt.params) return _impl_.params_; } // ------------------------------------------------------------------- // DeallocateStmt // string name = 1 [json_name = "name"]; inline void DeallocateStmt::clear_name() { _impl_.name_.ClearToEmpty(); } inline const std::string& DeallocateStmt::name() const { // @@protoc_insertion_point(field_get:pg_query.DeallocateStmt.name) return _internal_name(); } template inline PROTOBUF_ALWAYS_INLINE void DeallocateStmt::set_name(ArgT0&& arg0, ArgT... args) { _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.DeallocateStmt.name) } inline std::string* DeallocateStmt::mutable_name() { 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 { return _impl_.name_.Get(); } inline void DeallocateStmt::_internal_set_name(const std::string& value) { _impl_.name_.Set(value, GetArenaForAllocation()); } inline std::string* DeallocateStmt::_internal_mutable_name() { return _impl_.name_.Mutable(GetArenaForAllocation()); } inline std::string* DeallocateStmt::release_name() { // @@protoc_insertion_point(field_release:pg_query.DeallocateStmt.name) return _impl_.name_.Release(); } inline void DeallocateStmt::set_allocated_name(std::string* name) { if (name != nullptr) { } else { } _impl_.name_.SetAllocated(name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.name_.IsDefault()) { _impl_.name_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:pg_query.DeallocateStmt.name) } // ------------------------------------------------------------------- // DeclareCursorStmt // string portalname = 1 [json_name = "portalname"]; inline void DeclareCursorStmt::clear_portalname() { _impl_.portalname_.ClearToEmpty(); } inline const std::string& DeclareCursorStmt::portalname() const { // @@protoc_insertion_point(field_get:pg_query.DeclareCursorStmt.portalname) return _internal_portalname(); } template inline PROTOBUF_ALWAYS_INLINE void DeclareCursorStmt::set_portalname(ArgT0&& arg0, ArgT... args) { _impl_.portalname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.DeclareCursorStmt.portalname) } inline std::string* DeclareCursorStmt::mutable_portalname() { 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 { return _impl_.portalname_.Get(); } inline void DeclareCursorStmt::_internal_set_portalname(const std::string& value) { _impl_.portalname_.Set(value, GetArenaForAllocation()); } inline std::string* DeclareCursorStmt::_internal_mutable_portalname() { return _impl_.portalname_.Mutable(GetArenaForAllocation()); } inline std::string* DeclareCursorStmt::release_portalname() { // @@protoc_insertion_point(field_release:pg_query.DeclareCursorStmt.portalname) return _impl_.portalname_.Release(); } inline void DeclareCursorStmt::set_allocated_portalname(std::string* portalname) { if (portalname != nullptr) { } else { } _impl_.portalname_.SetAllocated(portalname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.portalname_.IsDefault()) { _impl_.portalname_.Set("", GetArenaForAllocation()); } #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() { _impl_.options_ = 0; } inline int32_t DeclareCursorStmt::_internal_options() const { return _impl_.options_; } inline int32_t DeclareCursorStmt::options() const { // @@protoc_insertion_point(field_get:pg_query.DeclareCursorStmt.options) return _internal_options(); } inline void DeclareCursorStmt::_internal_set_options(int32_t value) { _impl_.options_ = value; } inline void DeclareCursorStmt::set_options(int32_t value) { _internal_set_options(value); // @@protoc_insertion_point(field_set:pg_query.DeclareCursorStmt.options) } // .pg_query.Node query = 3 [json_name = "query"]; inline bool DeclareCursorStmt::_internal_has_query() const { return this != internal_default_instance() && _impl_.query_ != nullptr; } inline bool DeclareCursorStmt::has_query() const { return _internal_has_query(); } inline void DeclareCursorStmt::clear_query() { if (GetArenaForAllocation() == nullptr && _impl_.query_ != nullptr) { delete _impl_.query_; } _impl_.query_ = nullptr; } inline const ::pg_query::Node& DeclareCursorStmt::_internal_query() const { const ::pg_query::Node* p = _impl_.query_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& DeclareCursorStmt::query() const { // @@protoc_insertion_point(field_get:pg_query.DeclareCursorStmt.query) return _internal_query(); } inline void DeclareCursorStmt::unsafe_arena_set_allocated_query( ::pg_query::Node* query) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.query_); } _impl_.query_ = query; if (query) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.DeclareCursorStmt.query) } inline ::pg_query::Node* DeclareCursorStmt::release_query() { ::pg_query::Node* temp = _impl_.query_; _impl_.query_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* DeclareCursorStmt::unsafe_arena_release_query() { // @@protoc_insertion_point(field_release:pg_query.DeclareCursorStmt.query) ::pg_query::Node* temp = _impl_.query_; _impl_.query_ = nullptr; return temp; } inline ::pg_query::Node* DeclareCursorStmt::_internal_mutable_query() { if (_impl_.query_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.query_ = p; } return _impl_.query_; } inline ::pg_query::Node* DeclareCursorStmt::mutable_query() { ::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* query) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.query_; } if (query) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(query); if (message_arena != submessage_arena) { query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, query, submessage_arena); } } else { } _impl_.query_ = query; // @@protoc_insertion_point(field_set_allocated:pg_query.DeclareCursorStmt.query) } // ------------------------------------------------------------------- // CreateTableSpaceStmt // string tablespacename = 1 [json_name = "tablespacename"]; inline void CreateTableSpaceStmt::clear_tablespacename() { _impl_.tablespacename_.ClearToEmpty(); } inline const std::string& CreateTableSpaceStmt::tablespacename() const { // @@protoc_insertion_point(field_get:pg_query.CreateTableSpaceStmt.tablespacename) return _internal_tablespacename(); } template inline PROTOBUF_ALWAYS_INLINE void CreateTableSpaceStmt::set_tablespacename(ArgT0&& arg0, ArgT... args) { _impl_.tablespacename_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreateTableSpaceStmt.tablespacename) } inline std::string* CreateTableSpaceStmt::mutable_tablespacename() { 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 { return _impl_.tablespacename_.Get(); } inline void CreateTableSpaceStmt::_internal_set_tablespacename(const std::string& value) { _impl_.tablespacename_.Set(value, GetArenaForAllocation()); } inline std::string* CreateTableSpaceStmt::_internal_mutable_tablespacename() { return _impl_.tablespacename_.Mutable(GetArenaForAllocation()); } inline std::string* CreateTableSpaceStmt::release_tablespacename() { // @@protoc_insertion_point(field_release:pg_query.CreateTableSpaceStmt.tablespacename) return _impl_.tablespacename_.Release(); } inline void CreateTableSpaceStmt::set_allocated_tablespacename(std::string* tablespacename) { if (tablespacename != nullptr) { } else { } _impl_.tablespacename_.SetAllocated(tablespacename, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.tablespacename_.IsDefault()) { _impl_.tablespacename_.Set("", GetArenaForAllocation()); } #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::_internal_has_owner() const { return this != internal_default_instance() && _impl_.owner_ != nullptr; } inline bool CreateTableSpaceStmt::has_owner() const { return _internal_has_owner(); } inline void CreateTableSpaceStmt::clear_owner() { if (GetArenaForAllocation() == nullptr && _impl_.owner_ != nullptr) { delete _impl_.owner_; } _impl_.owner_ = nullptr; } inline const ::pg_query::RoleSpec& CreateTableSpaceStmt::_internal_owner() const { const ::pg_query::RoleSpec* p = _impl_.owner_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RoleSpec_default_instance_); } inline const ::pg_query::RoleSpec& CreateTableSpaceStmt::owner() const { // @@protoc_insertion_point(field_get:pg_query.CreateTableSpaceStmt.owner) return _internal_owner(); } inline void CreateTableSpaceStmt::unsafe_arena_set_allocated_owner( ::pg_query::RoleSpec* owner) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.owner_); } _impl_.owner_ = owner; if (owner) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateTableSpaceStmt.owner) } inline ::pg_query::RoleSpec* CreateTableSpaceStmt::release_owner() { ::pg_query::RoleSpec* temp = _impl_.owner_; _impl_.owner_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RoleSpec* CreateTableSpaceStmt::unsafe_arena_release_owner() { // @@protoc_insertion_point(field_release:pg_query.CreateTableSpaceStmt.owner) ::pg_query::RoleSpec* temp = _impl_.owner_; _impl_.owner_ = nullptr; return temp; } inline ::pg_query::RoleSpec* CreateTableSpaceStmt::_internal_mutable_owner() { if (_impl_.owner_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArenaForAllocation()); _impl_.owner_ = p; } return _impl_.owner_; } inline ::pg_query::RoleSpec* CreateTableSpaceStmt::mutable_owner() { ::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* owner) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.owner_; } if (owner) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(owner); if (message_arena != submessage_arena) { owner = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, owner, submessage_arena); } } else { } _impl_.owner_ = owner; // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTableSpaceStmt.owner) } // string location = 3 [json_name = "location"]; inline void CreateTableSpaceStmt::clear_location() { _impl_.location_.ClearToEmpty(); } inline const std::string& CreateTableSpaceStmt::location() const { // @@protoc_insertion_point(field_get:pg_query.CreateTableSpaceStmt.location) return _internal_location(); } template inline PROTOBUF_ALWAYS_INLINE void CreateTableSpaceStmt::set_location(ArgT0&& arg0, ArgT... args) { _impl_.location_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreateTableSpaceStmt.location) } inline std::string* CreateTableSpaceStmt::mutable_location() { 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 { return _impl_.location_.Get(); } inline void CreateTableSpaceStmt::_internal_set_location(const std::string& value) { _impl_.location_.Set(value, GetArenaForAllocation()); } inline std::string* CreateTableSpaceStmt::_internal_mutable_location() { return _impl_.location_.Mutable(GetArenaForAllocation()); } inline std::string* CreateTableSpaceStmt::release_location() { // @@protoc_insertion_point(field_release:pg_query.CreateTableSpaceStmt.location) return _impl_.location_.Release(); } inline void CreateTableSpaceStmt::set_allocated_location(std::string* location) { if (location != nullptr) { } else { } _impl_.location_.SetAllocated(location, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.location_.IsDefault()) { _impl_.location_.Set("", GetArenaForAllocation()); } #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 _impl_.options_.size(); } inline int CreateTableSpaceStmt::options_size() const { return _internal_options_size(); } inline void CreateTableSpaceStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* CreateTableSpaceStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateTableSpaceStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateTableSpaceStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateTableSpaceStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& CreateTableSpaceStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& CreateTableSpaceStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateTableSpaceStmt.options) return _internal_options(index); } inline ::pg_query::Node* CreateTableSpaceStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* CreateTableSpaceStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.CreateTableSpaceStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateTableSpaceStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.CreateTableSpaceStmt.options) return _impl_.options_; } // ------------------------------------------------------------------- // DropTableSpaceStmt // string tablespacename = 1 [json_name = "tablespacename"]; inline void DropTableSpaceStmt::clear_tablespacename() { _impl_.tablespacename_.ClearToEmpty(); } inline const std::string& DropTableSpaceStmt::tablespacename() const { // @@protoc_insertion_point(field_get:pg_query.DropTableSpaceStmt.tablespacename) return _internal_tablespacename(); } template inline PROTOBUF_ALWAYS_INLINE void DropTableSpaceStmt::set_tablespacename(ArgT0&& arg0, ArgT... args) { _impl_.tablespacename_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.DropTableSpaceStmt.tablespacename) } inline std::string* DropTableSpaceStmt::mutable_tablespacename() { 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 { return _impl_.tablespacename_.Get(); } inline void DropTableSpaceStmt::_internal_set_tablespacename(const std::string& value) { _impl_.tablespacename_.Set(value, GetArenaForAllocation()); } inline std::string* DropTableSpaceStmt::_internal_mutable_tablespacename() { return _impl_.tablespacename_.Mutable(GetArenaForAllocation()); } inline std::string* DropTableSpaceStmt::release_tablespacename() { // @@protoc_insertion_point(field_release:pg_query.DropTableSpaceStmt.tablespacename) return _impl_.tablespacename_.Release(); } inline void DropTableSpaceStmt::set_allocated_tablespacename(std::string* tablespacename) { if (tablespacename != nullptr) { } else { } _impl_.tablespacename_.SetAllocated(tablespacename, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.tablespacename_.IsDefault()) { _impl_.tablespacename_.Set("", GetArenaForAllocation()); } #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() { _impl_.missing_ok_ = false; } inline bool DropTableSpaceStmt::_internal_missing_ok() const { return _impl_.missing_ok_; } inline bool DropTableSpaceStmt::missing_ok() const { // @@protoc_insertion_point(field_get:pg_query.DropTableSpaceStmt.missing_ok) return _internal_missing_ok(); } inline void DropTableSpaceStmt::_internal_set_missing_ok(bool value) { _impl_.missing_ok_ = value; } inline void DropTableSpaceStmt::set_missing_ok(bool value) { _internal_set_missing_ok(value); // @@protoc_insertion_point(field_set:pg_query.DropTableSpaceStmt.missing_ok) } // ------------------------------------------------------------------- // AlterObjectDependsStmt // .pg_query.ObjectType object_type = 1 [json_name = "objectType"]; inline void AlterObjectDependsStmt::clear_object_type() { _impl_.object_type_ = 0; } inline ::pg_query::ObjectType AlterObjectDependsStmt::_internal_object_type() const { return static_cast< ::pg_query::ObjectType >(_impl_.object_type_); } inline ::pg_query::ObjectType AlterObjectDependsStmt::object_type() const { // @@protoc_insertion_point(field_get:pg_query.AlterObjectDependsStmt.object_type) return _internal_object_type(); } inline void AlterObjectDependsStmt::_internal_set_object_type(::pg_query::ObjectType value) { _impl_.object_type_ = value; } inline void AlterObjectDependsStmt::set_object_type(::pg_query::ObjectType value) { _internal_set_object_type(value); // @@protoc_insertion_point(field_set:pg_query.AlterObjectDependsStmt.object_type) } // .pg_query.RangeVar relation = 2 [json_name = "relation"]; inline bool AlterObjectDependsStmt::_internal_has_relation() const { return this != internal_default_instance() && _impl_.relation_ != nullptr; } inline bool AlterObjectDependsStmt::has_relation() const { return _internal_has_relation(); } inline void AlterObjectDependsStmt::clear_relation() { if (GetArenaForAllocation() == nullptr && _impl_.relation_ != nullptr) { delete _impl_.relation_; } _impl_.relation_ = nullptr; } inline const ::pg_query::RangeVar& AlterObjectDependsStmt::_internal_relation() const { const ::pg_query::RangeVar* p = _impl_.relation_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& AlterObjectDependsStmt::relation() const { // @@protoc_insertion_point(field_get:pg_query.AlterObjectDependsStmt.relation) return _internal_relation(); } inline void AlterObjectDependsStmt::unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.relation_); } _impl_.relation_ = relation; if (relation) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterObjectDependsStmt.relation) } inline ::pg_query::RangeVar* AlterObjectDependsStmt::release_relation() { ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* AlterObjectDependsStmt::unsafe_arena_release_relation() { // @@protoc_insertion_point(field_release:pg_query.AlterObjectDependsStmt.relation) ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; return temp; } inline ::pg_query::RangeVar* AlterObjectDependsStmt::_internal_mutable_relation() { if (_impl_.relation_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.relation_ = p; } return _impl_.relation_; } inline ::pg_query::RangeVar* AlterObjectDependsStmt::mutable_relation() { ::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* relation) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.relation_; } if (relation) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(relation); if (message_arena != submessage_arena) { relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, relation, submessage_arena); } } else { } _impl_.relation_ = relation; // @@protoc_insertion_point(field_set_allocated:pg_query.AlterObjectDependsStmt.relation) } // .pg_query.Node object = 3 [json_name = "object"]; inline bool AlterObjectDependsStmt::_internal_has_object() const { return this != internal_default_instance() && _impl_.object_ != nullptr; } inline bool AlterObjectDependsStmt::has_object() const { return _internal_has_object(); } inline void AlterObjectDependsStmt::clear_object() { if (GetArenaForAllocation() == nullptr && _impl_.object_ != nullptr) { delete _impl_.object_; } _impl_.object_ = nullptr; } inline const ::pg_query::Node& AlterObjectDependsStmt::_internal_object() const { const ::pg_query::Node* p = _impl_.object_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& AlterObjectDependsStmt::object() const { // @@protoc_insertion_point(field_get:pg_query.AlterObjectDependsStmt.object) return _internal_object(); } inline void AlterObjectDependsStmt::unsafe_arena_set_allocated_object( ::pg_query::Node* object) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.object_); } _impl_.object_ = object; if (object) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterObjectDependsStmt.object) } inline ::pg_query::Node* AlterObjectDependsStmt::release_object() { ::pg_query::Node* temp = _impl_.object_; _impl_.object_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* AlterObjectDependsStmt::unsafe_arena_release_object() { // @@protoc_insertion_point(field_release:pg_query.AlterObjectDependsStmt.object) ::pg_query::Node* temp = _impl_.object_; _impl_.object_ = nullptr; return temp; } inline ::pg_query::Node* AlterObjectDependsStmt::_internal_mutable_object() { if (_impl_.object_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.object_ = p; } return _impl_.object_; } inline ::pg_query::Node* AlterObjectDependsStmt::mutable_object() { ::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* object) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.object_; } if (object) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(object); if (message_arena != submessage_arena) { object = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, object, submessage_arena); } } else { } _impl_.object_ = object; // @@protoc_insertion_point(field_set_allocated:pg_query.AlterObjectDependsStmt.object) } // .pg_query.String extname = 4 [json_name = "extname"]; inline bool AlterObjectDependsStmt::_internal_has_extname() const { return this != internal_default_instance() && _impl_.extname_ != nullptr; } inline bool AlterObjectDependsStmt::has_extname() const { return _internal_has_extname(); } inline void AlterObjectDependsStmt::clear_extname() { if (GetArenaForAllocation() == nullptr && _impl_.extname_ != nullptr) { delete _impl_.extname_; } _impl_.extname_ = nullptr; } inline const ::pg_query::String& AlterObjectDependsStmt::_internal_extname() const { const ::pg_query::String* p = _impl_.extname_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_String_default_instance_); } inline const ::pg_query::String& AlterObjectDependsStmt::extname() const { // @@protoc_insertion_point(field_get:pg_query.AlterObjectDependsStmt.extname) return _internal_extname(); } inline void AlterObjectDependsStmt::unsafe_arena_set_allocated_extname( ::pg_query::String* extname) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.extname_); } _impl_.extname_ = extname; if (extname) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterObjectDependsStmt.extname) } inline ::pg_query::String* AlterObjectDependsStmt::release_extname() { ::pg_query::String* temp = _impl_.extname_; _impl_.extname_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::String* AlterObjectDependsStmt::unsafe_arena_release_extname() { // @@protoc_insertion_point(field_release:pg_query.AlterObjectDependsStmt.extname) ::pg_query::String* temp = _impl_.extname_; _impl_.extname_ = nullptr; return temp; } inline ::pg_query::String* AlterObjectDependsStmt::_internal_mutable_extname() { if (_impl_.extname_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::String>(GetArenaForAllocation()); _impl_.extname_ = p; } return _impl_.extname_; } inline ::pg_query::String* AlterObjectDependsStmt::mutable_extname() { ::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* extname) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.extname_; } if (extname) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(extname); if (message_arena != submessage_arena) { extname = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, extname, submessage_arena); } } else { } _impl_.extname_ = extname; // @@protoc_insertion_point(field_set_allocated:pg_query.AlterObjectDependsStmt.extname) } // bool remove = 5 [json_name = "remove"]; inline void AlterObjectDependsStmt::clear_remove() { _impl_.remove_ = false; } inline bool AlterObjectDependsStmt::_internal_remove() const { return _impl_.remove_; } inline bool AlterObjectDependsStmt::remove() const { // @@protoc_insertion_point(field_get:pg_query.AlterObjectDependsStmt.remove) return _internal_remove(); } inline void AlterObjectDependsStmt::_internal_set_remove(bool value) { _impl_.remove_ = value; } inline void AlterObjectDependsStmt::set_remove(bool value) { _internal_set_remove(value); // @@protoc_insertion_point(field_set:pg_query.AlterObjectDependsStmt.remove) } // ------------------------------------------------------------------- // AlterObjectSchemaStmt // .pg_query.ObjectType object_type = 1 [json_name = "objectType"]; inline void AlterObjectSchemaStmt::clear_object_type() { _impl_.object_type_ = 0; } inline ::pg_query::ObjectType AlterObjectSchemaStmt::_internal_object_type() const { return static_cast< ::pg_query::ObjectType >(_impl_.object_type_); } inline ::pg_query::ObjectType AlterObjectSchemaStmt::object_type() const { // @@protoc_insertion_point(field_get:pg_query.AlterObjectSchemaStmt.object_type) return _internal_object_type(); } inline void AlterObjectSchemaStmt::_internal_set_object_type(::pg_query::ObjectType value) { _impl_.object_type_ = value; } inline void AlterObjectSchemaStmt::set_object_type(::pg_query::ObjectType value) { _internal_set_object_type(value); // @@protoc_insertion_point(field_set:pg_query.AlterObjectSchemaStmt.object_type) } // .pg_query.RangeVar relation = 2 [json_name = "relation"]; inline bool AlterObjectSchemaStmt::_internal_has_relation() const { return this != internal_default_instance() && _impl_.relation_ != nullptr; } inline bool AlterObjectSchemaStmt::has_relation() const { return _internal_has_relation(); } inline void AlterObjectSchemaStmt::clear_relation() { if (GetArenaForAllocation() == nullptr && _impl_.relation_ != nullptr) { delete _impl_.relation_; } _impl_.relation_ = nullptr; } inline const ::pg_query::RangeVar& AlterObjectSchemaStmt::_internal_relation() const { const ::pg_query::RangeVar* p = _impl_.relation_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& AlterObjectSchemaStmt::relation() const { // @@protoc_insertion_point(field_get:pg_query.AlterObjectSchemaStmt.relation) return _internal_relation(); } inline void AlterObjectSchemaStmt::unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.relation_); } _impl_.relation_ = relation; if (relation) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterObjectSchemaStmt.relation) } inline ::pg_query::RangeVar* AlterObjectSchemaStmt::release_relation() { ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* AlterObjectSchemaStmt::unsafe_arena_release_relation() { // @@protoc_insertion_point(field_release:pg_query.AlterObjectSchemaStmt.relation) ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; return temp; } inline ::pg_query::RangeVar* AlterObjectSchemaStmt::_internal_mutable_relation() { if (_impl_.relation_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.relation_ = p; } return _impl_.relation_; } inline ::pg_query::RangeVar* AlterObjectSchemaStmt::mutable_relation() { ::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* relation) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.relation_; } if (relation) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(relation); if (message_arena != submessage_arena) { relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, relation, submessage_arena); } } else { } _impl_.relation_ = relation; // @@protoc_insertion_point(field_set_allocated:pg_query.AlterObjectSchemaStmt.relation) } // .pg_query.Node object = 3 [json_name = "object"]; inline bool AlterObjectSchemaStmt::_internal_has_object() const { return this != internal_default_instance() && _impl_.object_ != nullptr; } inline bool AlterObjectSchemaStmt::has_object() const { return _internal_has_object(); } inline void AlterObjectSchemaStmt::clear_object() { if (GetArenaForAllocation() == nullptr && _impl_.object_ != nullptr) { delete _impl_.object_; } _impl_.object_ = nullptr; } inline const ::pg_query::Node& AlterObjectSchemaStmt::_internal_object() const { const ::pg_query::Node* p = _impl_.object_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& AlterObjectSchemaStmt::object() const { // @@protoc_insertion_point(field_get:pg_query.AlterObjectSchemaStmt.object) return _internal_object(); } inline void AlterObjectSchemaStmt::unsafe_arena_set_allocated_object( ::pg_query::Node* object) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.object_); } _impl_.object_ = object; if (object) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterObjectSchemaStmt.object) } inline ::pg_query::Node* AlterObjectSchemaStmt::release_object() { ::pg_query::Node* temp = _impl_.object_; _impl_.object_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* AlterObjectSchemaStmt::unsafe_arena_release_object() { // @@protoc_insertion_point(field_release:pg_query.AlterObjectSchemaStmt.object) ::pg_query::Node* temp = _impl_.object_; _impl_.object_ = nullptr; return temp; } inline ::pg_query::Node* AlterObjectSchemaStmt::_internal_mutable_object() { if (_impl_.object_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.object_ = p; } return _impl_.object_; } inline ::pg_query::Node* AlterObjectSchemaStmt::mutable_object() { ::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* object) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.object_; } if (object) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(object); if (message_arena != submessage_arena) { object = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, object, submessage_arena); } } else { } _impl_.object_ = object; // @@protoc_insertion_point(field_set_allocated:pg_query.AlterObjectSchemaStmt.object) } // string newschema = 4 [json_name = "newschema"]; inline void AlterObjectSchemaStmt::clear_newschema() { _impl_.newschema_.ClearToEmpty(); } inline const std::string& AlterObjectSchemaStmt::newschema() const { // @@protoc_insertion_point(field_get:pg_query.AlterObjectSchemaStmt.newschema) return _internal_newschema(); } template inline PROTOBUF_ALWAYS_INLINE void AlterObjectSchemaStmt::set_newschema(ArgT0&& arg0, ArgT... args) { _impl_.newschema_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.AlterObjectSchemaStmt.newschema) } inline std::string* AlterObjectSchemaStmt::mutable_newschema() { 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 { return _impl_.newschema_.Get(); } inline void AlterObjectSchemaStmt::_internal_set_newschema(const std::string& value) { _impl_.newschema_.Set(value, GetArenaForAllocation()); } inline std::string* AlterObjectSchemaStmt::_internal_mutable_newschema() { return _impl_.newschema_.Mutable(GetArenaForAllocation()); } inline std::string* AlterObjectSchemaStmt::release_newschema() { // @@protoc_insertion_point(field_release:pg_query.AlterObjectSchemaStmt.newschema) return _impl_.newschema_.Release(); } inline void AlterObjectSchemaStmt::set_allocated_newschema(std::string* newschema) { if (newschema != nullptr) { } else { } _impl_.newschema_.SetAllocated(newschema, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.newschema_.IsDefault()) { _impl_.newschema_.Set("", GetArenaForAllocation()); } #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() { _impl_.missing_ok_ = false; } inline bool AlterObjectSchemaStmt::_internal_missing_ok() const { return _impl_.missing_ok_; } inline bool AlterObjectSchemaStmt::missing_ok() const { // @@protoc_insertion_point(field_get:pg_query.AlterObjectSchemaStmt.missing_ok) return _internal_missing_ok(); } inline void AlterObjectSchemaStmt::_internal_set_missing_ok(bool value) { _impl_.missing_ok_ = value; } inline void AlterObjectSchemaStmt::set_missing_ok(bool value) { _internal_set_missing_ok(value); // @@protoc_insertion_point(field_set:pg_query.AlterObjectSchemaStmt.missing_ok) } // ------------------------------------------------------------------- // AlterOwnerStmt // .pg_query.ObjectType object_type = 1 [json_name = "objectType"]; inline void AlterOwnerStmt::clear_object_type() { _impl_.object_type_ = 0; } inline ::pg_query::ObjectType AlterOwnerStmt::_internal_object_type() const { return static_cast< ::pg_query::ObjectType >(_impl_.object_type_); } inline ::pg_query::ObjectType AlterOwnerStmt::object_type() const { // @@protoc_insertion_point(field_get:pg_query.AlterOwnerStmt.object_type) return _internal_object_type(); } inline void AlterOwnerStmt::_internal_set_object_type(::pg_query::ObjectType value) { _impl_.object_type_ = value; } inline void AlterOwnerStmt::set_object_type(::pg_query::ObjectType value) { _internal_set_object_type(value); // @@protoc_insertion_point(field_set:pg_query.AlterOwnerStmt.object_type) } // .pg_query.RangeVar relation = 2 [json_name = "relation"]; inline bool AlterOwnerStmt::_internal_has_relation() const { return this != internal_default_instance() && _impl_.relation_ != nullptr; } inline bool AlterOwnerStmt::has_relation() const { return _internal_has_relation(); } inline void AlterOwnerStmt::clear_relation() { if (GetArenaForAllocation() == nullptr && _impl_.relation_ != nullptr) { delete _impl_.relation_; } _impl_.relation_ = nullptr; } inline const ::pg_query::RangeVar& AlterOwnerStmt::_internal_relation() const { const ::pg_query::RangeVar* p = _impl_.relation_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& AlterOwnerStmt::relation() const { // @@protoc_insertion_point(field_get:pg_query.AlterOwnerStmt.relation) return _internal_relation(); } inline void AlterOwnerStmt::unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.relation_); } _impl_.relation_ = relation; if (relation) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterOwnerStmt.relation) } inline ::pg_query::RangeVar* AlterOwnerStmt::release_relation() { ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* AlterOwnerStmt::unsafe_arena_release_relation() { // @@protoc_insertion_point(field_release:pg_query.AlterOwnerStmt.relation) ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; return temp; } inline ::pg_query::RangeVar* AlterOwnerStmt::_internal_mutable_relation() { if (_impl_.relation_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.relation_ = p; } return _impl_.relation_; } inline ::pg_query::RangeVar* AlterOwnerStmt::mutable_relation() { ::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* relation) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.relation_; } if (relation) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(relation); if (message_arena != submessage_arena) { relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, relation, submessage_arena); } } else { } _impl_.relation_ = relation; // @@protoc_insertion_point(field_set_allocated:pg_query.AlterOwnerStmt.relation) } // .pg_query.Node object = 3 [json_name = "object"]; inline bool AlterOwnerStmt::_internal_has_object() const { return this != internal_default_instance() && _impl_.object_ != nullptr; } inline bool AlterOwnerStmt::has_object() const { return _internal_has_object(); } inline void AlterOwnerStmt::clear_object() { if (GetArenaForAllocation() == nullptr && _impl_.object_ != nullptr) { delete _impl_.object_; } _impl_.object_ = nullptr; } inline const ::pg_query::Node& AlterOwnerStmt::_internal_object() const { const ::pg_query::Node* p = _impl_.object_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& AlterOwnerStmt::object() const { // @@protoc_insertion_point(field_get:pg_query.AlterOwnerStmt.object) return _internal_object(); } inline void AlterOwnerStmt::unsafe_arena_set_allocated_object( ::pg_query::Node* object) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.object_); } _impl_.object_ = object; if (object) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterOwnerStmt.object) } inline ::pg_query::Node* AlterOwnerStmt::release_object() { ::pg_query::Node* temp = _impl_.object_; _impl_.object_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* AlterOwnerStmt::unsafe_arena_release_object() { // @@protoc_insertion_point(field_release:pg_query.AlterOwnerStmt.object) ::pg_query::Node* temp = _impl_.object_; _impl_.object_ = nullptr; return temp; } inline ::pg_query::Node* AlterOwnerStmt::_internal_mutable_object() { if (_impl_.object_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.object_ = p; } return _impl_.object_; } inline ::pg_query::Node* AlterOwnerStmt::mutable_object() { ::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* object) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.object_; } if (object) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(object); if (message_arena != submessage_arena) { object = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, object, submessage_arena); } } else { } _impl_.object_ = object; // @@protoc_insertion_point(field_set_allocated:pg_query.AlterOwnerStmt.object) } // .pg_query.RoleSpec newowner = 4 [json_name = "newowner"]; inline bool AlterOwnerStmt::_internal_has_newowner() const { return this != internal_default_instance() && _impl_.newowner_ != nullptr; } inline bool AlterOwnerStmt::has_newowner() const { return _internal_has_newowner(); } inline void AlterOwnerStmt::clear_newowner() { if (GetArenaForAllocation() == nullptr && _impl_.newowner_ != nullptr) { delete _impl_.newowner_; } _impl_.newowner_ = nullptr; } inline const ::pg_query::RoleSpec& AlterOwnerStmt::_internal_newowner() const { const ::pg_query::RoleSpec* p = _impl_.newowner_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RoleSpec_default_instance_); } inline const ::pg_query::RoleSpec& AlterOwnerStmt::newowner() const { // @@protoc_insertion_point(field_get:pg_query.AlterOwnerStmt.newowner) return _internal_newowner(); } inline void AlterOwnerStmt::unsafe_arena_set_allocated_newowner( ::pg_query::RoleSpec* newowner) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.newowner_); } _impl_.newowner_ = newowner; if (newowner) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterOwnerStmt.newowner) } inline ::pg_query::RoleSpec* AlterOwnerStmt::release_newowner() { ::pg_query::RoleSpec* temp = _impl_.newowner_; _impl_.newowner_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RoleSpec* AlterOwnerStmt::unsafe_arena_release_newowner() { // @@protoc_insertion_point(field_release:pg_query.AlterOwnerStmt.newowner) ::pg_query::RoleSpec* temp = _impl_.newowner_; _impl_.newowner_ = nullptr; return temp; } inline ::pg_query::RoleSpec* AlterOwnerStmt::_internal_mutable_newowner() { if (_impl_.newowner_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArenaForAllocation()); _impl_.newowner_ = p; } return _impl_.newowner_; } inline ::pg_query::RoleSpec* AlterOwnerStmt::mutable_newowner() { ::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* newowner) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.newowner_; } if (newowner) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(newowner); if (message_arena != submessage_arena) { newowner = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, newowner, submessage_arena); } } else { } _impl_.newowner_ = newowner; // @@protoc_insertion_point(field_set_allocated:pg_query.AlterOwnerStmt.newowner) } // ------------------------------------------------------------------- // AlterOperatorStmt // .pg_query.ObjectWithArgs opername = 1 [json_name = "opername"]; inline bool AlterOperatorStmt::_internal_has_opername() const { return this != internal_default_instance() && _impl_.opername_ != nullptr; } inline bool AlterOperatorStmt::has_opername() const { return _internal_has_opername(); } inline void AlterOperatorStmt::clear_opername() { if (GetArenaForAllocation() == nullptr && _impl_.opername_ != nullptr) { delete _impl_.opername_; } _impl_.opername_ = nullptr; } inline const ::pg_query::ObjectWithArgs& AlterOperatorStmt::_internal_opername() const { const ::pg_query::ObjectWithArgs* p = _impl_.opername_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_ObjectWithArgs_default_instance_); } inline const ::pg_query::ObjectWithArgs& AlterOperatorStmt::opername() const { // @@protoc_insertion_point(field_get:pg_query.AlterOperatorStmt.opername) return _internal_opername(); } inline void AlterOperatorStmt::unsafe_arena_set_allocated_opername( ::pg_query::ObjectWithArgs* opername) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.opername_); } _impl_.opername_ = opername; if (opername) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterOperatorStmt.opername) } inline ::pg_query::ObjectWithArgs* AlterOperatorStmt::release_opername() { ::pg_query::ObjectWithArgs* temp = _impl_.opername_; _impl_.opername_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::ObjectWithArgs* AlterOperatorStmt::unsafe_arena_release_opername() { // @@protoc_insertion_point(field_release:pg_query.AlterOperatorStmt.opername) ::pg_query::ObjectWithArgs* temp = _impl_.opername_; _impl_.opername_ = nullptr; return temp; } inline ::pg_query::ObjectWithArgs* AlterOperatorStmt::_internal_mutable_opername() { if (_impl_.opername_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::ObjectWithArgs>(GetArenaForAllocation()); _impl_.opername_ = p; } return _impl_.opername_; } inline ::pg_query::ObjectWithArgs* AlterOperatorStmt::mutable_opername() { ::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* opername) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.opername_; } if (opername) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(opername); if (message_arena != submessage_arena) { opername = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, opername, submessage_arena); } } else { } _impl_.opername_ = opername; // @@protoc_insertion_point(field_set_allocated:pg_query.AlterOperatorStmt.opername) } // repeated .pg_query.Node options = 2 [json_name = "options"]; inline int AlterOperatorStmt::_internal_options_size() const { return _impl_.options_.size(); } inline int AlterOperatorStmt::options_size() const { return _internal_options_size(); } inline void AlterOperatorStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* AlterOperatorStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterOperatorStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterOperatorStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterOperatorStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& AlterOperatorStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& AlterOperatorStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterOperatorStmt.options) return _internal_options(index); } inline ::pg_query::Node* AlterOperatorStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* AlterOperatorStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.AlterOperatorStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterOperatorStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.AlterOperatorStmt.options) return _impl_.options_; } // ------------------------------------------------------------------- // AlterTypeStmt // repeated .pg_query.Node type_name = 1 [json_name = "typeName"]; inline int AlterTypeStmt::_internal_type_name_size() const { return _impl_.type_name_.size(); } inline int AlterTypeStmt::type_name_size() const { return _internal_type_name_size(); } inline void AlterTypeStmt::clear_type_name() { _impl_.type_name_.Clear(); } inline ::pg_query::Node* AlterTypeStmt::mutable_type_name(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterTypeStmt.type_name) return _impl_.type_name_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterTypeStmt::mutable_type_name() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTypeStmt.type_name) return &_impl_.type_name_; } inline const ::pg_query::Node& AlterTypeStmt::_internal_type_name(int index) const { return _impl_.type_name_.Get(index); } inline const ::pg_query::Node& AlterTypeStmt::type_name(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterTypeStmt.type_name) return _internal_type_name(index); } inline ::pg_query::Node* AlterTypeStmt::_internal_add_type_name() { return _impl_.type_name_.Add(); } inline ::pg_query::Node* AlterTypeStmt::add_type_name() { ::pg_query::Node* _add = _internal_add_type_name(); // @@protoc_insertion_point(field_add:pg_query.AlterTypeStmt.type_name) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterTypeStmt::type_name() const { // @@protoc_insertion_point(field_list:pg_query.AlterTypeStmt.type_name) return _impl_.type_name_; } // repeated .pg_query.Node options = 2 [json_name = "options"]; inline int AlterTypeStmt::_internal_options_size() const { return _impl_.options_.size(); } inline int AlterTypeStmt::options_size() const { return _internal_options_size(); } inline void AlterTypeStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* AlterTypeStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterTypeStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterTypeStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTypeStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& AlterTypeStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& AlterTypeStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterTypeStmt.options) return _internal_options(index); } inline ::pg_query::Node* AlterTypeStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* AlterTypeStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.AlterTypeStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterTypeStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.AlterTypeStmt.options) return _impl_.options_; } // ------------------------------------------------------------------- // DropOwnedStmt // repeated .pg_query.Node roles = 1 [json_name = "roles"]; inline int DropOwnedStmt::_internal_roles_size() const { return _impl_.roles_.size(); } inline int DropOwnedStmt::roles_size() const { return _internal_roles_size(); } inline void DropOwnedStmt::clear_roles() { _impl_.roles_.Clear(); } inline ::pg_query::Node* DropOwnedStmt::mutable_roles(int index) { // @@protoc_insertion_point(field_mutable:pg_query.DropOwnedStmt.roles) return _impl_.roles_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* DropOwnedStmt::mutable_roles() { // @@protoc_insertion_point(field_mutable_list:pg_query.DropOwnedStmt.roles) return &_impl_.roles_; } inline const ::pg_query::Node& DropOwnedStmt::_internal_roles(int index) const { return _impl_.roles_.Get(index); } inline const ::pg_query::Node& DropOwnedStmt::roles(int index) const { // @@protoc_insertion_point(field_get:pg_query.DropOwnedStmt.roles) return _internal_roles(index); } inline ::pg_query::Node* DropOwnedStmt::_internal_add_roles() { return _impl_.roles_.Add(); } inline ::pg_query::Node* DropOwnedStmt::add_roles() { ::pg_query::Node* _add = _internal_add_roles(); // @@protoc_insertion_point(field_add:pg_query.DropOwnedStmt.roles) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& DropOwnedStmt::roles() const { // @@protoc_insertion_point(field_list:pg_query.DropOwnedStmt.roles) return _impl_.roles_; } // .pg_query.DropBehavior behavior = 2 [json_name = "behavior"]; inline void DropOwnedStmt::clear_behavior() { _impl_.behavior_ = 0; } inline ::pg_query::DropBehavior DropOwnedStmt::_internal_behavior() const { return static_cast< ::pg_query::DropBehavior >(_impl_.behavior_); } inline ::pg_query::DropBehavior DropOwnedStmt::behavior() const { // @@protoc_insertion_point(field_get:pg_query.DropOwnedStmt.behavior) return _internal_behavior(); } inline void DropOwnedStmt::_internal_set_behavior(::pg_query::DropBehavior value) { _impl_.behavior_ = value; } inline void DropOwnedStmt::set_behavior(::pg_query::DropBehavior value) { _internal_set_behavior(value); // @@protoc_insertion_point(field_set:pg_query.DropOwnedStmt.behavior) } // ------------------------------------------------------------------- // ReassignOwnedStmt // repeated .pg_query.Node roles = 1 [json_name = "roles"]; inline int ReassignOwnedStmt::_internal_roles_size() const { return _impl_.roles_.size(); } inline int ReassignOwnedStmt::roles_size() const { return _internal_roles_size(); } inline void ReassignOwnedStmt::clear_roles() { _impl_.roles_.Clear(); } inline ::pg_query::Node* ReassignOwnedStmt::mutable_roles(int index) { // @@protoc_insertion_point(field_mutable:pg_query.ReassignOwnedStmt.roles) return _impl_.roles_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* ReassignOwnedStmt::mutable_roles() { // @@protoc_insertion_point(field_mutable_list:pg_query.ReassignOwnedStmt.roles) return &_impl_.roles_; } inline const ::pg_query::Node& ReassignOwnedStmt::_internal_roles(int index) const { return _impl_.roles_.Get(index); } inline const ::pg_query::Node& ReassignOwnedStmt::roles(int index) const { // @@protoc_insertion_point(field_get:pg_query.ReassignOwnedStmt.roles) return _internal_roles(index); } inline ::pg_query::Node* ReassignOwnedStmt::_internal_add_roles() { return _impl_.roles_.Add(); } inline ::pg_query::Node* ReassignOwnedStmt::add_roles() { ::pg_query::Node* _add = _internal_add_roles(); // @@protoc_insertion_point(field_add:pg_query.ReassignOwnedStmt.roles) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& ReassignOwnedStmt::roles() const { // @@protoc_insertion_point(field_list:pg_query.ReassignOwnedStmt.roles) return _impl_.roles_; } // .pg_query.RoleSpec newrole = 2 [json_name = "newrole"]; inline bool ReassignOwnedStmt::_internal_has_newrole() const { return this != internal_default_instance() && _impl_.newrole_ != nullptr; } inline bool ReassignOwnedStmt::has_newrole() const { return _internal_has_newrole(); } inline void ReassignOwnedStmt::clear_newrole() { if (GetArenaForAllocation() == nullptr && _impl_.newrole_ != nullptr) { delete _impl_.newrole_; } _impl_.newrole_ = nullptr; } inline const ::pg_query::RoleSpec& ReassignOwnedStmt::_internal_newrole() const { const ::pg_query::RoleSpec* p = _impl_.newrole_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RoleSpec_default_instance_); } inline const ::pg_query::RoleSpec& ReassignOwnedStmt::newrole() const { // @@protoc_insertion_point(field_get:pg_query.ReassignOwnedStmt.newrole) return _internal_newrole(); } inline void ReassignOwnedStmt::unsafe_arena_set_allocated_newrole( ::pg_query::RoleSpec* newrole) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.newrole_); } _impl_.newrole_ = newrole; if (newrole) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ReassignOwnedStmt.newrole) } inline ::pg_query::RoleSpec* ReassignOwnedStmt::release_newrole() { ::pg_query::RoleSpec* temp = _impl_.newrole_; _impl_.newrole_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RoleSpec* ReassignOwnedStmt::unsafe_arena_release_newrole() { // @@protoc_insertion_point(field_release:pg_query.ReassignOwnedStmt.newrole) ::pg_query::RoleSpec* temp = _impl_.newrole_; _impl_.newrole_ = nullptr; return temp; } inline ::pg_query::RoleSpec* ReassignOwnedStmt::_internal_mutable_newrole() { if (_impl_.newrole_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArenaForAllocation()); _impl_.newrole_ = p; } return _impl_.newrole_; } inline ::pg_query::RoleSpec* ReassignOwnedStmt::mutable_newrole() { ::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* newrole) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.newrole_; } if (newrole) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(newrole); if (message_arena != submessage_arena) { newrole = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, newrole, submessage_arena); } } else { } _impl_.newrole_ = newrole; // @@protoc_insertion_point(field_set_allocated:pg_query.ReassignOwnedStmt.newrole) } // ------------------------------------------------------------------- // CompositeTypeStmt // .pg_query.RangeVar typevar = 1 [json_name = "typevar"]; inline bool CompositeTypeStmt::_internal_has_typevar() const { return this != internal_default_instance() && _impl_.typevar_ != nullptr; } inline bool CompositeTypeStmt::has_typevar() const { return _internal_has_typevar(); } inline void CompositeTypeStmt::clear_typevar() { if (GetArenaForAllocation() == nullptr && _impl_.typevar_ != nullptr) { delete _impl_.typevar_; } _impl_.typevar_ = nullptr; } inline const ::pg_query::RangeVar& CompositeTypeStmt::_internal_typevar() const { const ::pg_query::RangeVar* p = _impl_.typevar_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& CompositeTypeStmt::typevar() const { // @@protoc_insertion_point(field_get:pg_query.CompositeTypeStmt.typevar) return _internal_typevar(); } inline void CompositeTypeStmt::unsafe_arena_set_allocated_typevar( ::pg_query::RangeVar* typevar) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.typevar_); } _impl_.typevar_ = typevar; if (typevar) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CompositeTypeStmt.typevar) } inline ::pg_query::RangeVar* CompositeTypeStmt::release_typevar() { ::pg_query::RangeVar* temp = _impl_.typevar_; _impl_.typevar_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* CompositeTypeStmt::unsafe_arena_release_typevar() { // @@protoc_insertion_point(field_release:pg_query.CompositeTypeStmt.typevar) ::pg_query::RangeVar* temp = _impl_.typevar_; _impl_.typevar_ = nullptr; return temp; } inline ::pg_query::RangeVar* CompositeTypeStmt::_internal_mutable_typevar() { if (_impl_.typevar_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.typevar_ = p; } return _impl_.typevar_; } inline ::pg_query::RangeVar* CompositeTypeStmt::mutable_typevar() { ::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* typevar) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.typevar_; } if (typevar) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(typevar); if (message_arena != submessage_arena) { typevar = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, typevar, submessage_arena); } } else { } _impl_.typevar_ = typevar; // @@protoc_insertion_point(field_set_allocated:pg_query.CompositeTypeStmt.typevar) } // repeated .pg_query.Node coldeflist = 2 [json_name = "coldeflist"]; inline int CompositeTypeStmt::_internal_coldeflist_size() const { return _impl_.coldeflist_.size(); } inline int CompositeTypeStmt::coldeflist_size() const { return _internal_coldeflist_size(); } inline void CompositeTypeStmt::clear_coldeflist() { _impl_.coldeflist_.Clear(); } inline ::pg_query::Node* CompositeTypeStmt::mutable_coldeflist(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CompositeTypeStmt.coldeflist) return _impl_.coldeflist_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CompositeTypeStmt::mutable_coldeflist() { // @@protoc_insertion_point(field_mutable_list:pg_query.CompositeTypeStmt.coldeflist) return &_impl_.coldeflist_; } inline const ::pg_query::Node& CompositeTypeStmt::_internal_coldeflist(int index) const { return _impl_.coldeflist_.Get(index); } inline const ::pg_query::Node& CompositeTypeStmt::coldeflist(int index) const { // @@protoc_insertion_point(field_get:pg_query.CompositeTypeStmt.coldeflist) return _internal_coldeflist(index); } inline ::pg_query::Node* CompositeTypeStmt::_internal_add_coldeflist() { return _impl_.coldeflist_.Add(); } inline ::pg_query::Node* CompositeTypeStmt::add_coldeflist() { ::pg_query::Node* _add = _internal_add_coldeflist(); // @@protoc_insertion_point(field_add:pg_query.CompositeTypeStmt.coldeflist) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CompositeTypeStmt::coldeflist() const { // @@protoc_insertion_point(field_list:pg_query.CompositeTypeStmt.coldeflist) return _impl_.coldeflist_; } // ------------------------------------------------------------------- // CreateEnumStmt // repeated .pg_query.Node type_name = 1 [json_name = "typeName"]; inline int CreateEnumStmt::_internal_type_name_size() const { return _impl_.type_name_.size(); } inline int CreateEnumStmt::type_name_size() const { return _internal_type_name_size(); } inline void CreateEnumStmt::clear_type_name() { _impl_.type_name_.Clear(); } inline ::pg_query::Node* CreateEnumStmt::mutable_type_name(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateEnumStmt.type_name) return _impl_.type_name_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateEnumStmt::mutable_type_name() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateEnumStmt.type_name) return &_impl_.type_name_; } inline const ::pg_query::Node& CreateEnumStmt::_internal_type_name(int index) const { return _impl_.type_name_.Get(index); } inline const ::pg_query::Node& CreateEnumStmt::type_name(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateEnumStmt.type_name) return _internal_type_name(index); } inline ::pg_query::Node* CreateEnumStmt::_internal_add_type_name() { return _impl_.type_name_.Add(); } inline ::pg_query::Node* CreateEnumStmt::add_type_name() { ::pg_query::Node* _add = _internal_add_type_name(); // @@protoc_insertion_point(field_add:pg_query.CreateEnumStmt.type_name) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateEnumStmt::type_name() const { // @@protoc_insertion_point(field_list:pg_query.CreateEnumStmt.type_name) return _impl_.type_name_; } // repeated .pg_query.Node vals = 2 [json_name = "vals"]; inline int CreateEnumStmt::_internal_vals_size() const { return _impl_.vals_.size(); } inline int CreateEnumStmt::vals_size() const { return _internal_vals_size(); } inline void CreateEnumStmt::clear_vals() { _impl_.vals_.Clear(); } inline ::pg_query::Node* CreateEnumStmt::mutable_vals(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateEnumStmt.vals) return _impl_.vals_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateEnumStmt::mutable_vals() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateEnumStmt.vals) return &_impl_.vals_; } inline const ::pg_query::Node& CreateEnumStmt::_internal_vals(int index) const { return _impl_.vals_.Get(index); } inline const ::pg_query::Node& CreateEnumStmt::vals(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateEnumStmt.vals) return _internal_vals(index); } inline ::pg_query::Node* CreateEnumStmt::_internal_add_vals() { return _impl_.vals_.Add(); } inline ::pg_query::Node* CreateEnumStmt::add_vals() { ::pg_query::Node* _add = _internal_add_vals(); // @@protoc_insertion_point(field_add:pg_query.CreateEnumStmt.vals) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateEnumStmt::vals() const { // @@protoc_insertion_point(field_list:pg_query.CreateEnumStmt.vals) return _impl_.vals_; } // ------------------------------------------------------------------- // CreateRangeStmt // repeated .pg_query.Node type_name = 1 [json_name = "typeName"]; inline int CreateRangeStmt::_internal_type_name_size() const { return _impl_.type_name_.size(); } inline int CreateRangeStmt::type_name_size() const { return _internal_type_name_size(); } inline void CreateRangeStmt::clear_type_name() { _impl_.type_name_.Clear(); } inline ::pg_query::Node* CreateRangeStmt::mutable_type_name(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateRangeStmt.type_name) return _impl_.type_name_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateRangeStmt::mutable_type_name() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateRangeStmt.type_name) return &_impl_.type_name_; } inline const ::pg_query::Node& CreateRangeStmt::_internal_type_name(int index) const { return _impl_.type_name_.Get(index); } inline const ::pg_query::Node& CreateRangeStmt::type_name(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateRangeStmt.type_name) return _internal_type_name(index); } inline ::pg_query::Node* CreateRangeStmt::_internal_add_type_name() { return _impl_.type_name_.Add(); } inline ::pg_query::Node* CreateRangeStmt::add_type_name() { ::pg_query::Node* _add = _internal_add_type_name(); // @@protoc_insertion_point(field_add:pg_query.CreateRangeStmt.type_name) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateRangeStmt::type_name() const { // @@protoc_insertion_point(field_list:pg_query.CreateRangeStmt.type_name) return _impl_.type_name_; } // repeated .pg_query.Node params = 2 [json_name = "params"]; inline int CreateRangeStmt::_internal_params_size() const { return _impl_.params_.size(); } inline int CreateRangeStmt::params_size() const { return _internal_params_size(); } inline void CreateRangeStmt::clear_params() { _impl_.params_.Clear(); } inline ::pg_query::Node* CreateRangeStmt::mutable_params(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateRangeStmt.params) return _impl_.params_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateRangeStmt::mutable_params() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateRangeStmt.params) return &_impl_.params_; } inline const ::pg_query::Node& CreateRangeStmt::_internal_params(int index) const { return _impl_.params_.Get(index); } inline const ::pg_query::Node& CreateRangeStmt::params(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateRangeStmt.params) return _internal_params(index); } inline ::pg_query::Node* CreateRangeStmt::_internal_add_params() { return _impl_.params_.Add(); } inline ::pg_query::Node* CreateRangeStmt::add_params() { ::pg_query::Node* _add = _internal_add_params(); // @@protoc_insertion_point(field_add:pg_query.CreateRangeStmt.params) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateRangeStmt::params() const { // @@protoc_insertion_point(field_list:pg_query.CreateRangeStmt.params) return _impl_.params_; } // ------------------------------------------------------------------- // AlterEnumStmt // repeated .pg_query.Node type_name = 1 [json_name = "typeName"]; inline int AlterEnumStmt::_internal_type_name_size() const { return _impl_.type_name_.size(); } inline int AlterEnumStmt::type_name_size() const { return _internal_type_name_size(); } inline void AlterEnumStmt::clear_type_name() { _impl_.type_name_.Clear(); } inline ::pg_query::Node* AlterEnumStmt::mutable_type_name(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterEnumStmt.type_name) return _impl_.type_name_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterEnumStmt::mutable_type_name() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterEnumStmt.type_name) return &_impl_.type_name_; } inline const ::pg_query::Node& AlterEnumStmt::_internal_type_name(int index) const { return _impl_.type_name_.Get(index); } inline const ::pg_query::Node& AlterEnumStmt::type_name(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterEnumStmt.type_name) return _internal_type_name(index); } inline ::pg_query::Node* AlterEnumStmt::_internal_add_type_name() { return _impl_.type_name_.Add(); } inline ::pg_query::Node* AlterEnumStmt::add_type_name() { ::pg_query::Node* _add = _internal_add_type_name(); // @@protoc_insertion_point(field_add:pg_query.AlterEnumStmt.type_name) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterEnumStmt::type_name() const { // @@protoc_insertion_point(field_list:pg_query.AlterEnumStmt.type_name) return _impl_.type_name_; } // string old_val = 2 [json_name = "oldVal"]; inline void AlterEnumStmt::clear_old_val() { _impl_.old_val_.ClearToEmpty(); } inline const std::string& AlterEnumStmt::old_val() const { // @@protoc_insertion_point(field_get:pg_query.AlterEnumStmt.old_val) return _internal_old_val(); } template inline PROTOBUF_ALWAYS_INLINE void AlterEnumStmt::set_old_val(ArgT0&& arg0, ArgT... args) { _impl_.old_val_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.AlterEnumStmt.old_val) } inline std::string* AlterEnumStmt::mutable_old_val() { 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 { return _impl_.old_val_.Get(); } inline void AlterEnumStmt::_internal_set_old_val(const std::string& value) { _impl_.old_val_.Set(value, GetArenaForAllocation()); } inline std::string* AlterEnumStmt::_internal_mutable_old_val() { return _impl_.old_val_.Mutable(GetArenaForAllocation()); } inline std::string* AlterEnumStmt::release_old_val() { // @@protoc_insertion_point(field_release:pg_query.AlterEnumStmt.old_val) return _impl_.old_val_.Release(); } inline void AlterEnumStmt::set_allocated_old_val(std::string* old_val) { if (old_val != nullptr) { } else { } _impl_.old_val_.SetAllocated(old_val, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.old_val_.IsDefault()) { _impl_.old_val_.Set("", GetArenaForAllocation()); } #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() { _impl_.new_val_.ClearToEmpty(); } inline const std::string& AlterEnumStmt::new_val() const { // @@protoc_insertion_point(field_get:pg_query.AlterEnumStmt.new_val) return _internal_new_val(); } template inline PROTOBUF_ALWAYS_INLINE void AlterEnumStmt::set_new_val(ArgT0&& arg0, ArgT... args) { _impl_.new_val_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.AlterEnumStmt.new_val) } inline std::string* AlterEnumStmt::mutable_new_val() { 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 { return _impl_.new_val_.Get(); } inline void AlterEnumStmt::_internal_set_new_val(const std::string& value) { _impl_.new_val_.Set(value, GetArenaForAllocation()); } inline std::string* AlterEnumStmt::_internal_mutable_new_val() { return _impl_.new_val_.Mutable(GetArenaForAllocation()); } inline std::string* AlterEnumStmt::release_new_val() { // @@protoc_insertion_point(field_release:pg_query.AlterEnumStmt.new_val) return _impl_.new_val_.Release(); } inline void AlterEnumStmt::set_allocated_new_val(std::string* new_val) { if (new_val != nullptr) { } else { } _impl_.new_val_.SetAllocated(new_val, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.new_val_.IsDefault()) { _impl_.new_val_.Set("", GetArenaForAllocation()); } #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() { _impl_.new_val_neighbor_.ClearToEmpty(); } inline const std::string& AlterEnumStmt::new_val_neighbor() const { // @@protoc_insertion_point(field_get:pg_query.AlterEnumStmt.new_val_neighbor) return _internal_new_val_neighbor(); } template inline PROTOBUF_ALWAYS_INLINE void AlterEnumStmt::set_new_val_neighbor(ArgT0&& arg0, ArgT... args) { _impl_.new_val_neighbor_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.AlterEnumStmt.new_val_neighbor) } inline std::string* AlterEnumStmt::mutable_new_val_neighbor() { 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 { return _impl_.new_val_neighbor_.Get(); } inline void AlterEnumStmt::_internal_set_new_val_neighbor(const std::string& value) { _impl_.new_val_neighbor_.Set(value, GetArenaForAllocation()); } inline std::string* AlterEnumStmt::_internal_mutable_new_val_neighbor() { return _impl_.new_val_neighbor_.Mutable(GetArenaForAllocation()); } inline std::string* AlterEnumStmt::release_new_val_neighbor() { // @@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* new_val_neighbor) { if (new_val_neighbor != nullptr) { } else { } _impl_.new_val_neighbor_.SetAllocated(new_val_neighbor, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.new_val_neighbor_.IsDefault()) { _impl_.new_val_neighbor_.Set("", GetArenaForAllocation()); } #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() { _impl_.new_val_is_after_ = false; } inline bool AlterEnumStmt::_internal_new_val_is_after() const { return _impl_.new_val_is_after_; } inline bool AlterEnumStmt::new_val_is_after() const { // @@protoc_insertion_point(field_get:pg_query.AlterEnumStmt.new_val_is_after) return _internal_new_val_is_after(); } inline void AlterEnumStmt::_internal_set_new_val_is_after(bool value) { _impl_.new_val_is_after_ = value; } inline void AlterEnumStmt::set_new_val_is_after(bool value) { _internal_set_new_val_is_after(value); // @@protoc_insertion_point(field_set:pg_query.AlterEnumStmt.new_val_is_after) } // bool skip_if_new_val_exists = 6 [json_name = "skipIfNewValExists"]; inline void AlterEnumStmt::clear_skip_if_new_val_exists() { _impl_.skip_if_new_val_exists_ = false; } inline bool AlterEnumStmt::_internal_skip_if_new_val_exists() const { return _impl_.skip_if_new_val_exists_; } inline bool AlterEnumStmt::skip_if_new_val_exists() const { // @@protoc_insertion_point(field_get:pg_query.AlterEnumStmt.skip_if_new_val_exists) return _internal_skip_if_new_val_exists(); } inline void AlterEnumStmt::_internal_set_skip_if_new_val_exists(bool value) { _impl_.skip_if_new_val_exists_ = value; } inline void AlterEnumStmt::set_skip_if_new_val_exists(bool value) { _internal_set_skip_if_new_val_exists(value); // @@protoc_insertion_point(field_set:pg_query.AlterEnumStmt.skip_if_new_val_exists) } // ------------------------------------------------------------------- // AlterTSDictionaryStmt // repeated .pg_query.Node dictname = 1 [json_name = "dictname"]; inline int AlterTSDictionaryStmt::_internal_dictname_size() const { return _impl_.dictname_.size(); } inline int AlterTSDictionaryStmt::dictname_size() const { return _internal_dictname_size(); } inline void AlterTSDictionaryStmt::clear_dictname() { _impl_.dictname_.Clear(); } inline ::pg_query::Node* AlterTSDictionaryStmt::mutable_dictname(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterTSDictionaryStmt.dictname) return _impl_.dictname_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterTSDictionaryStmt::mutable_dictname() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTSDictionaryStmt.dictname) return &_impl_.dictname_; } inline const ::pg_query::Node& AlterTSDictionaryStmt::_internal_dictname(int index) const { return _impl_.dictname_.Get(index); } inline const ::pg_query::Node& AlterTSDictionaryStmt::dictname(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterTSDictionaryStmt.dictname) return _internal_dictname(index); } inline ::pg_query::Node* AlterTSDictionaryStmt::_internal_add_dictname() { return _impl_.dictname_.Add(); } inline ::pg_query::Node* AlterTSDictionaryStmt::add_dictname() { ::pg_query::Node* _add = _internal_add_dictname(); // @@protoc_insertion_point(field_add:pg_query.AlterTSDictionaryStmt.dictname) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterTSDictionaryStmt::dictname() const { // @@protoc_insertion_point(field_list:pg_query.AlterTSDictionaryStmt.dictname) return _impl_.dictname_; } // repeated .pg_query.Node options = 2 [json_name = "options"]; inline int AlterTSDictionaryStmt::_internal_options_size() const { return _impl_.options_.size(); } inline int AlterTSDictionaryStmt::options_size() const { return _internal_options_size(); } inline void AlterTSDictionaryStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* AlterTSDictionaryStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterTSDictionaryStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterTSDictionaryStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTSDictionaryStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& AlterTSDictionaryStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& AlterTSDictionaryStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterTSDictionaryStmt.options) return _internal_options(index); } inline ::pg_query::Node* AlterTSDictionaryStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* AlterTSDictionaryStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.AlterTSDictionaryStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterTSDictionaryStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.AlterTSDictionaryStmt.options) return _impl_.options_; } // ------------------------------------------------------------------- // AlterTSConfigurationStmt // .pg_query.AlterTSConfigType kind = 1 [json_name = "kind"]; inline void AlterTSConfigurationStmt::clear_kind() { _impl_.kind_ = 0; } inline ::pg_query::AlterTSConfigType AlterTSConfigurationStmt::_internal_kind() const { return static_cast< ::pg_query::AlterTSConfigType >(_impl_.kind_); } inline ::pg_query::AlterTSConfigType AlterTSConfigurationStmt::kind() const { // @@protoc_insertion_point(field_get:pg_query.AlterTSConfigurationStmt.kind) return _internal_kind(); } inline void AlterTSConfigurationStmt::_internal_set_kind(::pg_query::AlterTSConfigType value) { _impl_.kind_ = value; } inline void AlterTSConfigurationStmt::set_kind(::pg_query::AlterTSConfigType value) { _internal_set_kind(value); // @@protoc_insertion_point(field_set:pg_query.AlterTSConfigurationStmt.kind) } // repeated .pg_query.Node cfgname = 2 [json_name = "cfgname"]; inline int AlterTSConfigurationStmt::_internal_cfgname_size() const { return _impl_.cfgname_.size(); } inline int AlterTSConfigurationStmt::cfgname_size() const { return _internal_cfgname_size(); } inline void AlterTSConfigurationStmt::clear_cfgname() { _impl_.cfgname_.Clear(); } inline ::pg_query::Node* AlterTSConfigurationStmt::mutable_cfgname(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterTSConfigurationStmt.cfgname) return _impl_.cfgname_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterTSConfigurationStmt::mutable_cfgname() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTSConfigurationStmt.cfgname) return &_impl_.cfgname_; } inline const ::pg_query::Node& AlterTSConfigurationStmt::_internal_cfgname(int index) const { return _impl_.cfgname_.Get(index); } inline const ::pg_query::Node& AlterTSConfigurationStmt::cfgname(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterTSConfigurationStmt.cfgname) return _internal_cfgname(index); } inline ::pg_query::Node* AlterTSConfigurationStmt::_internal_add_cfgname() { return _impl_.cfgname_.Add(); } inline ::pg_query::Node* AlterTSConfigurationStmt::add_cfgname() { ::pg_query::Node* _add = _internal_add_cfgname(); // @@protoc_insertion_point(field_add:pg_query.AlterTSConfigurationStmt.cfgname) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterTSConfigurationStmt::cfgname() const { // @@protoc_insertion_point(field_list:pg_query.AlterTSConfigurationStmt.cfgname) return _impl_.cfgname_; } // repeated .pg_query.Node tokentype = 3 [json_name = "tokentype"]; inline int AlterTSConfigurationStmt::_internal_tokentype_size() const { return _impl_.tokentype_.size(); } inline int AlterTSConfigurationStmt::tokentype_size() const { return _internal_tokentype_size(); } inline void AlterTSConfigurationStmt::clear_tokentype() { _impl_.tokentype_.Clear(); } inline ::pg_query::Node* AlterTSConfigurationStmt::mutable_tokentype(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterTSConfigurationStmt.tokentype) return _impl_.tokentype_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterTSConfigurationStmt::mutable_tokentype() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTSConfigurationStmt.tokentype) return &_impl_.tokentype_; } inline const ::pg_query::Node& AlterTSConfigurationStmt::_internal_tokentype(int index) const { return _impl_.tokentype_.Get(index); } inline const ::pg_query::Node& AlterTSConfigurationStmt::tokentype(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterTSConfigurationStmt.tokentype) return _internal_tokentype(index); } inline ::pg_query::Node* AlterTSConfigurationStmt::_internal_add_tokentype() { return _impl_.tokentype_.Add(); } inline ::pg_query::Node* AlterTSConfigurationStmt::add_tokentype() { ::pg_query::Node* _add = _internal_add_tokentype(); // @@protoc_insertion_point(field_add:pg_query.AlterTSConfigurationStmt.tokentype) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterTSConfigurationStmt::tokentype() const { // @@protoc_insertion_point(field_list:pg_query.AlterTSConfigurationStmt.tokentype) return _impl_.tokentype_; } // repeated .pg_query.Node dicts = 4 [json_name = "dicts"]; inline int AlterTSConfigurationStmt::_internal_dicts_size() const { return _impl_.dicts_.size(); } inline int AlterTSConfigurationStmt::dicts_size() const { return _internal_dicts_size(); } inline void AlterTSConfigurationStmt::clear_dicts() { _impl_.dicts_.Clear(); } inline ::pg_query::Node* AlterTSConfigurationStmt::mutable_dicts(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterTSConfigurationStmt.dicts) return _impl_.dicts_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterTSConfigurationStmt::mutable_dicts() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTSConfigurationStmt.dicts) return &_impl_.dicts_; } inline const ::pg_query::Node& AlterTSConfigurationStmt::_internal_dicts(int index) const { return _impl_.dicts_.Get(index); } inline const ::pg_query::Node& AlterTSConfigurationStmt::dicts(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterTSConfigurationStmt.dicts) return _internal_dicts(index); } inline ::pg_query::Node* AlterTSConfigurationStmt::_internal_add_dicts() { return _impl_.dicts_.Add(); } inline ::pg_query::Node* AlterTSConfigurationStmt::add_dicts() { ::pg_query::Node* _add = _internal_add_dicts(); // @@protoc_insertion_point(field_add:pg_query.AlterTSConfigurationStmt.dicts) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterTSConfigurationStmt::dicts() const { // @@protoc_insertion_point(field_list:pg_query.AlterTSConfigurationStmt.dicts) return _impl_.dicts_; } // bool override = 5 [json_name = "override"]; inline void AlterTSConfigurationStmt::clear_override() { _impl_.override_ = false; } inline bool AlterTSConfigurationStmt::_internal_override() const { return _impl_.override_; } inline bool AlterTSConfigurationStmt::override() const { // @@protoc_insertion_point(field_get:pg_query.AlterTSConfigurationStmt.override) return _internal_override(); } inline void AlterTSConfigurationStmt::_internal_set_override(bool value) { _impl_.override_ = value; } inline void AlterTSConfigurationStmt::set_override(bool value) { _internal_set_override(value); // @@protoc_insertion_point(field_set:pg_query.AlterTSConfigurationStmt.override) } // bool replace = 6 [json_name = "replace"]; inline void AlterTSConfigurationStmt::clear_replace() { _impl_.replace_ = false; } inline bool AlterTSConfigurationStmt::_internal_replace() const { return _impl_.replace_; } inline bool AlterTSConfigurationStmt::replace() const { // @@protoc_insertion_point(field_get:pg_query.AlterTSConfigurationStmt.replace) return _internal_replace(); } inline void AlterTSConfigurationStmt::_internal_set_replace(bool value) { _impl_.replace_ = value; } inline void AlterTSConfigurationStmt::set_replace(bool value) { _internal_set_replace(value); // @@protoc_insertion_point(field_set:pg_query.AlterTSConfigurationStmt.replace) } // bool missing_ok = 7 [json_name = "missing_ok"]; inline void AlterTSConfigurationStmt::clear_missing_ok() { _impl_.missing_ok_ = false; } inline bool AlterTSConfigurationStmt::_internal_missing_ok() const { return _impl_.missing_ok_; } inline bool AlterTSConfigurationStmt::missing_ok() const { // @@protoc_insertion_point(field_get:pg_query.AlterTSConfigurationStmt.missing_ok) return _internal_missing_ok(); } inline void AlterTSConfigurationStmt::_internal_set_missing_ok(bool value) { _impl_.missing_ok_ = value; } inline void AlterTSConfigurationStmt::set_missing_ok(bool value) { _internal_set_missing_ok(value); // @@protoc_insertion_point(field_set:pg_query.AlterTSConfigurationStmt.missing_ok) } // ------------------------------------------------------------------- // CreateFdwStmt // string fdwname = 1 [json_name = "fdwname"]; inline void CreateFdwStmt::clear_fdwname() { _impl_.fdwname_.ClearToEmpty(); } inline const std::string& CreateFdwStmt::fdwname() const { // @@protoc_insertion_point(field_get:pg_query.CreateFdwStmt.fdwname) return _internal_fdwname(); } template inline PROTOBUF_ALWAYS_INLINE void CreateFdwStmt::set_fdwname(ArgT0&& arg0, ArgT... args) { _impl_.fdwname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreateFdwStmt.fdwname) } inline std::string* CreateFdwStmt::mutable_fdwname() { 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 { return _impl_.fdwname_.Get(); } inline void CreateFdwStmt::_internal_set_fdwname(const std::string& value) { _impl_.fdwname_.Set(value, GetArenaForAllocation()); } inline std::string* CreateFdwStmt::_internal_mutable_fdwname() { return _impl_.fdwname_.Mutable(GetArenaForAllocation()); } inline std::string* CreateFdwStmt::release_fdwname() { // @@protoc_insertion_point(field_release:pg_query.CreateFdwStmt.fdwname) return _impl_.fdwname_.Release(); } inline void CreateFdwStmt::set_allocated_fdwname(std::string* fdwname) { if (fdwname != nullptr) { } else { } _impl_.fdwname_.SetAllocated(fdwname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.fdwname_.IsDefault()) { _impl_.fdwname_.Set("", GetArenaForAllocation()); } #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 _impl_.func_options_.size(); } inline int CreateFdwStmt::func_options_size() const { return _internal_func_options_size(); } inline void CreateFdwStmt::clear_func_options() { _impl_.func_options_.Clear(); } inline ::pg_query::Node* CreateFdwStmt::mutable_func_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateFdwStmt.func_options) return _impl_.func_options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateFdwStmt::mutable_func_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateFdwStmt.func_options) return &_impl_.func_options_; } inline const ::pg_query::Node& CreateFdwStmt::_internal_func_options(int index) const { return _impl_.func_options_.Get(index); } inline const ::pg_query::Node& CreateFdwStmt::func_options(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateFdwStmt.func_options) return _internal_func_options(index); } inline ::pg_query::Node* CreateFdwStmt::_internal_add_func_options() { return _impl_.func_options_.Add(); } inline ::pg_query::Node* CreateFdwStmt::add_func_options() { ::pg_query::Node* _add = _internal_add_func_options(); // @@protoc_insertion_point(field_add:pg_query.CreateFdwStmt.func_options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateFdwStmt::func_options() const { // @@protoc_insertion_point(field_list:pg_query.CreateFdwStmt.func_options) return _impl_.func_options_; } // repeated .pg_query.Node options = 3 [json_name = "options"]; inline int CreateFdwStmt::_internal_options_size() const { return _impl_.options_.size(); } inline int CreateFdwStmt::options_size() const { return _internal_options_size(); } inline void CreateFdwStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* CreateFdwStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateFdwStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateFdwStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateFdwStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& CreateFdwStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& CreateFdwStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateFdwStmt.options) return _internal_options(index); } inline ::pg_query::Node* CreateFdwStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* CreateFdwStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.CreateFdwStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateFdwStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.CreateFdwStmt.options) return _impl_.options_; } // ------------------------------------------------------------------- // AlterFdwStmt // string fdwname = 1 [json_name = "fdwname"]; inline void AlterFdwStmt::clear_fdwname() { _impl_.fdwname_.ClearToEmpty(); } inline const std::string& AlterFdwStmt::fdwname() const { // @@protoc_insertion_point(field_get:pg_query.AlterFdwStmt.fdwname) return _internal_fdwname(); } template inline PROTOBUF_ALWAYS_INLINE void AlterFdwStmt::set_fdwname(ArgT0&& arg0, ArgT... args) { _impl_.fdwname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.AlterFdwStmt.fdwname) } inline std::string* AlterFdwStmt::mutable_fdwname() { 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 { return _impl_.fdwname_.Get(); } inline void AlterFdwStmt::_internal_set_fdwname(const std::string& value) { _impl_.fdwname_.Set(value, GetArenaForAllocation()); } inline std::string* AlterFdwStmt::_internal_mutable_fdwname() { return _impl_.fdwname_.Mutable(GetArenaForAllocation()); } inline std::string* AlterFdwStmt::release_fdwname() { // @@protoc_insertion_point(field_release:pg_query.AlterFdwStmt.fdwname) return _impl_.fdwname_.Release(); } inline void AlterFdwStmt::set_allocated_fdwname(std::string* fdwname) { if (fdwname != nullptr) { } else { } _impl_.fdwname_.SetAllocated(fdwname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.fdwname_.IsDefault()) { _impl_.fdwname_.Set("", GetArenaForAllocation()); } #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 _impl_.func_options_.size(); } inline int AlterFdwStmt::func_options_size() const { return _internal_func_options_size(); } inline void AlterFdwStmt::clear_func_options() { _impl_.func_options_.Clear(); } inline ::pg_query::Node* AlterFdwStmt::mutable_func_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterFdwStmt.func_options) return _impl_.func_options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterFdwStmt::mutable_func_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterFdwStmt.func_options) return &_impl_.func_options_; } inline const ::pg_query::Node& AlterFdwStmt::_internal_func_options(int index) const { return _impl_.func_options_.Get(index); } inline const ::pg_query::Node& AlterFdwStmt::func_options(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterFdwStmt.func_options) return _internal_func_options(index); } inline ::pg_query::Node* AlterFdwStmt::_internal_add_func_options() { return _impl_.func_options_.Add(); } inline ::pg_query::Node* AlterFdwStmt::add_func_options() { ::pg_query::Node* _add = _internal_add_func_options(); // @@protoc_insertion_point(field_add:pg_query.AlterFdwStmt.func_options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterFdwStmt::func_options() const { // @@protoc_insertion_point(field_list:pg_query.AlterFdwStmt.func_options) return _impl_.func_options_; } // repeated .pg_query.Node options = 3 [json_name = "options"]; inline int AlterFdwStmt::_internal_options_size() const { return _impl_.options_.size(); } inline int AlterFdwStmt::options_size() const { return _internal_options_size(); } inline void AlterFdwStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* AlterFdwStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterFdwStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterFdwStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterFdwStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& AlterFdwStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& AlterFdwStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterFdwStmt.options) return _internal_options(index); } inline ::pg_query::Node* AlterFdwStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* AlterFdwStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.AlterFdwStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterFdwStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.AlterFdwStmt.options) return _impl_.options_; } // ------------------------------------------------------------------- // CreateForeignServerStmt // string servername = 1 [json_name = "servername"]; inline void CreateForeignServerStmt::clear_servername() { _impl_.servername_.ClearToEmpty(); } inline const std::string& CreateForeignServerStmt::servername() const { // @@protoc_insertion_point(field_get:pg_query.CreateForeignServerStmt.servername) return _internal_servername(); } template inline PROTOBUF_ALWAYS_INLINE void CreateForeignServerStmt::set_servername(ArgT0&& arg0, ArgT... args) { _impl_.servername_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreateForeignServerStmt.servername) } inline std::string* CreateForeignServerStmt::mutable_servername() { 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 { return _impl_.servername_.Get(); } inline void CreateForeignServerStmt::_internal_set_servername(const std::string& value) { _impl_.servername_.Set(value, GetArenaForAllocation()); } inline std::string* CreateForeignServerStmt::_internal_mutable_servername() { return _impl_.servername_.Mutable(GetArenaForAllocation()); } inline std::string* CreateForeignServerStmt::release_servername() { // @@protoc_insertion_point(field_release:pg_query.CreateForeignServerStmt.servername) return _impl_.servername_.Release(); } inline void CreateForeignServerStmt::set_allocated_servername(std::string* servername) { if (servername != nullptr) { } else { } _impl_.servername_.SetAllocated(servername, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.servername_.IsDefault()) { _impl_.servername_.Set("", GetArenaForAllocation()); } #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() { _impl_.servertype_.ClearToEmpty(); } inline const std::string& CreateForeignServerStmt::servertype() const { // @@protoc_insertion_point(field_get:pg_query.CreateForeignServerStmt.servertype) return _internal_servertype(); } template inline PROTOBUF_ALWAYS_INLINE void CreateForeignServerStmt::set_servertype(ArgT0&& arg0, ArgT... args) { _impl_.servertype_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreateForeignServerStmt.servertype) } inline std::string* CreateForeignServerStmt::mutable_servertype() { 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 { return _impl_.servertype_.Get(); } inline void CreateForeignServerStmt::_internal_set_servertype(const std::string& value) { _impl_.servertype_.Set(value, GetArenaForAllocation()); } inline std::string* CreateForeignServerStmt::_internal_mutable_servertype() { return _impl_.servertype_.Mutable(GetArenaForAllocation()); } inline std::string* CreateForeignServerStmt::release_servertype() { // @@protoc_insertion_point(field_release:pg_query.CreateForeignServerStmt.servertype) return _impl_.servertype_.Release(); } inline void CreateForeignServerStmt::set_allocated_servertype(std::string* servertype) { if (servertype != nullptr) { } else { } _impl_.servertype_.SetAllocated(servertype, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.servertype_.IsDefault()) { _impl_.servertype_.Set("", GetArenaForAllocation()); } #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() { _impl_.version_.ClearToEmpty(); } inline const std::string& CreateForeignServerStmt::version() const { // @@protoc_insertion_point(field_get:pg_query.CreateForeignServerStmt.version) return _internal_version(); } template inline PROTOBUF_ALWAYS_INLINE void CreateForeignServerStmt::set_version(ArgT0&& arg0, ArgT... args) { _impl_.version_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreateForeignServerStmt.version) } inline std::string* CreateForeignServerStmt::mutable_version() { 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 { return _impl_.version_.Get(); } inline void CreateForeignServerStmt::_internal_set_version(const std::string& value) { _impl_.version_.Set(value, GetArenaForAllocation()); } inline std::string* CreateForeignServerStmt::_internal_mutable_version() { return _impl_.version_.Mutable(GetArenaForAllocation()); } inline std::string* CreateForeignServerStmt::release_version() { // @@protoc_insertion_point(field_release:pg_query.CreateForeignServerStmt.version) return _impl_.version_.Release(); } inline void CreateForeignServerStmt::set_allocated_version(std::string* version) { if (version != nullptr) { } else { } _impl_.version_.SetAllocated(version, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.version_.IsDefault()) { _impl_.version_.Set("", GetArenaForAllocation()); } #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() { _impl_.fdwname_.ClearToEmpty(); } inline const std::string& CreateForeignServerStmt::fdwname() const { // @@protoc_insertion_point(field_get:pg_query.CreateForeignServerStmt.fdwname) return _internal_fdwname(); } template inline PROTOBUF_ALWAYS_INLINE void CreateForeignServerStmt::set_fdwname(ArgT0&& arg0, ArgT... args) { _impl_.fdwname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreateForeignServerStmt.fdwname) } inline std::string* CreateForeignServerStmt::mutable_fdwname() { 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 { return _impl_.fdwname_.Get(); } inline void CreateForeignServerStmt::_internal_set_fdwname(const std::string& value) { _impl_.fdwname_.Set(value, GetArenaForAllocation()); } inline std::string* CreateForeignServerStmt::_internal_mutable_fdwname() { return _impl_.fdwname_.Mutable(GetArenaForAllocation()); } inline std::string* CreateForeignServerStmt::release_fdwname() { // @@protoc_insertion_point(field_release:pg_query.CreateForeignServerStmt.fdwname) return _impl_.fdwname_.Release(); } inline void CreateForeignServerStmt::set_allocated_fdwname(std::string* fdwname) { if (fdwname != nullptr) { } else { } _impl_.fdwname_.SetAllocated(fdwname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.fdwname_.IsDefault()) { _impl_.fdwname_.Set("", GetArenaForAllocation()); } #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() { _impl_.if_not_exists_ = false; } inline bool CreateForeignServerStmt::_internal_if_not_exists() const { return _impl_.if_not_exists_; } inline bool CreateForeignServerStmt::if_not_exists() const { // @@protoc_insertion_point(field_get:pg_query.CreateForeignServerStmt.if_not_exists) return _internal_if_not_exists(); } inline void CreateForeignServerStmt::_internal_set_if_not_exists(bool value) { _impl_.if_not_exists_ = value; } inline void CreateForeignServerStmt::set_if_not_exists(bool value) { _internal_set_if_not_exists(value); // @@protoc_insertion_point(field_set:pg_query.CreateForeignServerStmt.if_not_exists) } // repeated .pg_query.Node options = 6 [json_name = "options"]; inline int CreateForeignServerStmt::_internal_options_size() const { return _impl_.options_.size(); } inline int CreateForeignServerStmt::options_size() const { return _internal_options_size(); } inline void CreateForeignServerStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* CreateForeignServerStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateForeignServerStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateForeignServerStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateForeignServerStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& CreateForeignServerStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& CreateForeignServerStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateForeignServerStmt.options) return _internal_options(index); } inline ::pg_query::Node* CreateForeignServerStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* CreateForeignServerStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.CreateForeignServerStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateForeignServerStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.CreateForeignServerStmt.options) return _impl_.options_; } // ------------------------------------------------------------------- // AlterForeignServerStmt // string servername = 1 [json_name = "servername"]; inline void AlterForeignServerStmt::clear_servername() { _impl_.servername_.ClearToEmpty(); } inline const std::string& AlterForeignServerStmt::servername() const { // @@protoc_insertion_point(field_get:pg_query.AlterForeignServerStmt.servername) return _internal_servername(); } template inline PROTOBUF_ALWAYS_INLINE void AlterForeignServerStmt::set_servername(ArgT0&& arg0, ArgT... args) { _impl_.servername_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.AlterForeignServerStmt.servername) } inline std::string* AlterForeignServerStmt::mutable_servername() { 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 { return _impl_.servername_.Get(); } inline void AlterForeignServerStmt::_internal_set_servername(const std::string& value) { _impl_.servername_.Set(value, GetArenaForAllocation()); } inline std::string* AlterForeignServerStmt::_internal_mutable_servername() { return _impl_.servername_.Mutable(GetArenaForAllocation()); } inline std::string* AlterForeignServerStmt::release_servername() { // @@protoc_insertion_point(field_release:pg_query.AlterForeignServerStmt.servername) return _impl_.servername_.Release(); } inline void AlterForeignServerStmt::set_allocated_servername(std::string* servername) { if (servername != nullptr) { } else { } _impl_.servername_.SetAllocated(servername, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.servername_.IsDefault()) { _impl_.servername_.Set("", GetArenaForAllocation()); } #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() { _impl_.version_.ClearToEmpty(); } inline const std::string& AlterForeignServerStmt::version() const { // @@protoc_insertion_point(field_get:pg_query.AlterForeignServerStmt.version) return _internal_version(); } template inline PROTOBUF_ALWAYS_INLINE void AlterForeignServerStmt::set_version(ArgT0&& arg0, ArgT... args) { _impl_.version_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.AlterForeignServerStmt.version) } inline std::string* AlterForeignServerStmt::mutable_version() { 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 { return _impl_.version_.Get(); } inline void AlterForeignServerStmt::_internal_set_version(const std::string& value) { _impl_.version_.Set(value, GetArenaForAllocation()); } inline std::string* AlterForeignServerStmt::_internal_mutable_version() { return _impl_.version_.Mutable(GetArenaForAllocation()); } inline std::string* AlterForeignServerStmt::release_version() { // @@protoc_insertion_point(field_release:pg_query.AlterForeignServerStmt.version) return _impl_.version_.Release(); } inline void AlterForeignServerStmt::set_allocated_version(std::string* version) { if (version != nullptr) { } else { } _impl_.version_.SetAllocated(version, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.version_.IsDefault()) { _impl_.version_.Set("", GetArenaForAllocation()); } #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 _impl_.options_.size(); } inline int AlterForeignServerStmt::options_size() const { return _internal_options_size(); } inline void AlterForeignServerStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* AlterForeignServerStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterForeignServerStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterForeignServerStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterForeignServerStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& AlterForeignServerStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& AlterForeignServerStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterForeignServerStmt.options) return _internal_options(index); } inline ::pg_query::Node* AlterForeignServerStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* AlterForeignServerStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.AlterForeignServerStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterForeignServerStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.AlterForeignServerStmt.options) return _impl_.options_; } // bool has_version = 4 [json_name = "has_version"]; inline void AlterForeignServerStmt::clear_has_version() { _impl_.has_version_ = false; } inline bool AlterForeignServerStmt::_internal_has_version() const { return _impl_.has_version_; } inline bool AlterForeignServerStmt::has_version() const { // @@protoc_insertion_point(field_get:pg_query.AlterForeignServerStmt.has_version) return _internal_has_version(); } inline void AlterForeignServerStmt::_internal_set_has_version(bool value) { _impl_.has_version_ = value; } inline void AlterForeignServerStmt::set_has_version(bool value) { _internal_set_has_version(value); // @@protoc_insertion_point(field_set:pg_query.AlterForeignServerStmt.has_version) } // ------------------------------------------------------------------- // CreateUserMappingStmt // .pg_query.RoleSpec user = 1 [json_name = "user"]; inline bool CreateUserMappingStmt::_internal_has_user() const { return this != internal_default_instance() && _impl_.user_ != nullptr; } inline bool CreateUserMappingStmt::has_user() const { return _internal_has_user(); } inline void CreateUserMappingStmt::clear_user() { if (GetArenaForAllocation() == nullptr && _impl_.user_ != nullptr) { delete _impl_.user_; } _impl_.user_ = nullptr; } inline const ::pg_query::RoleSpec& CreateUserMappingStmt::_internal_user() const { const ::pg_query::RoleSpec* p = _impl_.user_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RoleSpec_default_instance_); } inline const ::pg_query::RoleSpec& CreateUserMappingStmt::user() const { // @@protoc_insertion_point(field_get:pg_query.CreateUserMappingStmt.user) return _internal_user(); } inline void CreateUserMappingStmt::unsafe_arena_set_allocated_user( ::pg_query::RoleSpec* user) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.user_); } _impl_.user_ = user; if (user) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateUserMappingStmt.user) } inline ::pg_query::RoleSpec* CreateUserMappingStmt::release_user() { ::pg_query::RoleSpec* temp = _impl_.user_; _impl_.user_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RoleSpec* CreateUserMappingStmt::unsafe_arena_release_user() { // @@protoc_insertion_point(field_release:pg_query.CreateUserMappingStmt.user) ::pg_query::RoleSpec* temp = _impl_.user_; _impl_.user_ = nullptr; return temp; } inline ::pg_query::RoleSpec* CreateUserMappingStmt::_internal_mutable_user() { if (_impl_.user_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArenaForAllocation()); _impl_.user_ = p; } return _impl_.user_; } inline ::pg_query::RoleSpec* CreateUserMappingStmt::mutable_user() { ::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* user) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.user_; } if (user) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(user); if (message_arena != submessage_arena) { user = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, user, submessage_arena); } } else { } _impl_.user_ = user; // @@protoc_insertion_point(field_set_allocated:pg_query.CreateUserMappingStmt.user) } // string servername = 2 [json_name = "servername"]; inline void CreateUserMappingStmt::clear_servername() { _impl_.servername_.ClearToEmpty(); } inline const std::string& CreateUserMappingStmt::servername() const { // @@protoc_insertion_point(field_get:pg_query.CreateUserMappingStmt.servername) return _internal_servername(); } template inline PROTOBUF_ALWAYS_INLINE void CreateUserMappingStmt::set_servername(ArgT0&& arg0, ArgT... args) { _impl_.servername_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreateUserMappingStmt.servername) } inline std::string* CreateUserMappingStmt::mutable_servername() { 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 { return _impl_.servername_.Get(); } inline void CreateUserMappingStmt::_internal_set_servername(const std::string& value) { _impl_.servername_.Set(value, GetArenaForAllocation()); } inline std::string* CreateUserMappingStmt::_internal_mutable_servername() { return _impl_.servername_.Mutable(GetArenaForAllocation()); } inline std::string* CreateUserMappingStmt::release_servername() { // @@protoc_insertion_point(field_release:pg_query.CreateUserMappingStmt.servername) return _impl_.servername_.Release(); } inline void CreateUserMappingStmt::set_allocated_servername(std::string* servername) { if (servername != nullptr) { } else { } _impl_.servername_.SetAllocated(servername, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.servername_.IsDefault()) { _impl_.servername_.Set("", GetArenaForAllocation()); } #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() { _impl_.if_not_exists_ = false; } inline bool CreateUserMappingStmt::_internal_if_not_exists() const { return _impl_.if_not_exists_; } inline bool CreateUserMappingStmt::if_not_exists() const { // @@protoc_insertion_point(field_get:pg_query.CreateUserMappingStmt.if_not_exists) return _internal_if_not_exists(); } inline void CreateUserMappingStmt::_internal_set_if_not_exists(bool value) { _impl_.if_not_exists_ = value; } inline void CreateUserMappingStmt::set_if_not_exists(bool value) { _internal_set_if_not_exists(value); // @@protoc_insertion_point(field_set:pg_query.CreateUserMappingStmt.if_not_exists) } // repeated .pg_query.Node options = 4 [json_name = "options"]; inline int CreateUserMappingStmt::_internal_options_size() const { return _impl_.options_.size(); } inline int CreateUserMappingStmt::options_size() const { return _internal_options_size(); } inline void CreateUserMappingStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* CreateUserMappingStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateUserMappingStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateUserMappingStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateUserMappingStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& CreateUserMappingStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& CreateUserMappingStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateUserMappingStmt.options) return _internal_options(index); } inline ::pg_query::Node* CreateUserMappingStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* CreateUserMappingStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.CreateUserMappingStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateUserMappingStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.CreateUserMappingStmt.options) return _impl_.options_; } // ------------------------------------------------------------------- // AlterUserMappingStmt // .pg_query.RoleSpec user = 1 [json_name = "user"]; inline bool AlterUserMappingStmt::_internal_has_user() const { return this != internal_default_instance() && _impl_.user_ != nullptr; } inline bool AlterUserMappingStmt::has_user() const { return _internal_has_user(); } inline void AlterUserMappingStmt::clear_user() { if (GetArenaForAllocation() == nullptr && _impl_.user_ != nullptr) { delete _impl_.user_; } _impl_.user_ = nullptr; } inline const ::pg_query::RoleSpec& AlterUserMappingStmt::_internal_user() const { const ::pg_query::RoleSpec* p = _impl_.user_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RoleSpec_default_instance_); } inline const ::pg_query::RoleSpec& AlterUserMappingStmt::user() const { // @@protoc_insertion_point(field_get:pg_query.AlterUserMappingStmt.user) return _internal_user(); } inline void AlterUserMappingStmt::unsafe_arena_set_allocated_user( ::pg_query::RoleSpec* user) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.user_); } _impl_.user_ = user; if (user) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterUserMappingStmt.user) } inline ::pg_query::RoleSpec* AlterUserMappingStmt::release_user() { ::pg_query::RoleSpec* temp = _impl_.user_; _impl_.user_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RoleSpec* AlterUserMappingStmt::unsafe_arena_release_user() { // @@protoc_insertion_point(field_release:pg_query.AlterUserMappingStmt.user) ::pg_query::RoleSpec* temp = _impl_.user_; _impl_.user_ = nullptr; return temp; } inline ::pg_query::RoleSpec* AlterUserMappingStmt::_internal_mutable_user() { if (_impl_.user_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArenaForAllocation()); _impl_.user_ = p; } return _impl_.user_; } inline ::pg_query::RoleSpec* AlterUserMappingStmt::mutable_user() { ::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* user) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.user_; } if (user) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(user); if (message_arena != submessage_arena) { user = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, user, submessage_arena); } } else { } _impl_.user_ = user; // @@protoc_insertion_point(field_set_allocated:pg_query.AlterUserMappingStmt.user) } // string servername = 2 [json_name = "servername"]; inline void AlterUserMappingStmt::clear_servername() { _impl_.servername_.ClearToEmpty(); } inline const std::string& AlterUserMappingStmt::servername() const { // @@protoc_insertion_point(field_get:pg_query.AlterUserMappingStmt.servername) return _internal_servername(); } template inline PROTOBUF_ALWAYS_INLINE void AlterUserMappingStmt::set_servername(ArgT0&& arg0, ArgT... args) { _impl_.servername_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.AlterUserMappingStmt.servername) } inline std::string* AlterUserMappingStmt::mutable_servername() { 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 { return _impl_.servername_.Get(); } inline void AlterUserMappingStmt::_internal_set_servername(const std::string& value) { _impl_.servername_.Set(value, GetArenaForAllocation()); } inline std::string* AlterUserMappingStmt::_internal_mutable_servername() { return _impl_.servername_.Mutable(GetArenaForAllocation()); } inline std::string* AlterUserMappingStmt::release_servername() { // @@protoc_insertion_point(field_release:pg_query.AlterUserMappingStmt.servername) return _impl_.servername_.Release(); } inline void AlterUserMappingStmt::set_allocated_servername(std::string* servername) { if (servername != nullptr) { } else { } _impl_.servername_.SetAllocated(servername, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.servername_.IsDefault()) { _impl_.servername_.Set("", GetArenaForAllocation()); } #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 _impl_.options_.size(); } inline int AlterUserMappingStmt::options_size() const { return _internal_options_size(); } inline void AlterUserMappingStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* AlterUserMappingStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterUserMappingStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterUserMappingStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterUserMappingStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& AlterUserMappingStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& AlterUserMappingStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterUserMappingStmt.options) return _internal_options(index); } inline ::pg_query::Node* AlterUserMappingStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* AlterUserMappingStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.AlterUserMappingStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterUserMappingStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.AlterUserMappingStmt.options) return _impl_.options_; } // ------------------------------------------------------------------- // DropUserMappingStmt // .pg_query.RoleSpec user = 1 [json_name = "user"]; inline bool DropUserMappingStmt::_internal_has_user() const { return this != internal_default_instance() && _impl_.user_ != nullptr; } inline bool DropUserMappingStmt::has_user() const { return _internal_has_user(); } inline void DropUserMappingStmt::clear_user() { if (GetArenaForAllocation() == nullptr && _impl_.user_ != nullptr) { delete _impl_.user_; } _impl_.user_ = nullptr; } inline const ::pg_query::RoleSpec& DropUserMappingStmt::_internal_user() const { const ::pg_query::RoleSpec* p = _impl_.user_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RoleSpec_default_instance_); } inline const ::pg_query::RoleSpec& DropUserMappingStmt::user() const { // @@protoc_insertion_point(field_get:pg_query.DropUserMappingStmt.user) return _internal_user(); } inline void DropUserMappingStmt::unsafe_arena_set_allocated_user( ::pg_query::RoleSpec* user) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.user_); } _impl_.user_ = user; if (user) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.DropUserMappingStmt.user) } inline ::pg_query::RoleSpec* DropUserMappingStmt::release_user() { ::pg_query::RoleSpec* temp = _impl_.user_; _impl_.user_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RoleSpec* DropUserMappingStmt::unsafe_arena_release_user() { // @@protoc_insertion_point(field_release:pg_query.DropUserMappingStmt.user) ::pg_query::RoleSpec* temp = _impl_.user_; _impl_.user_ = nullptr; return temp; } inline ::pg_query::RoleSpec* DropUserMappingStmt::_internal_mutable_user() { if (_impl_.user_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RoleSpec>(GetArenaForAllocation()); _impl_.user_ = p; } return _impl_.user_; } inline ::pg_query::RoleSpec* DropUserMappingStmt::mutable_user() { ::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* user) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.user_; } if (user) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(user); if (message_arena != submessage_arena) { user = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, user, submessage_arena); } } else { } _impl_.user_ = user; // @@protoc_insertion_point(field_set_allocated:pg_query.DropUserMappingStmt.user) } // string servername = 2 [json_name = "servername"]; inline void DropUserMappingStmt::clear_servername() { _impl_.servername_.ClearToEmpty(); } inline const std::string& DropUserMappingStmt::servername() const { // @@protoc_insertion_point(field_get:pg_query.DropUserMappingStmt.servername) return _internal_servername(); } template inline PROTOBUF_ALWAYS_INLINE void DropUserMappingStmt::set_servername(ArgT0&& arg0, ArgT... args) { _impl_.servername_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.DropUserMappingStmt.servername) } inline std::string* DropUserMappingStmt::mutable_servername() { 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 { return _impl_.servername_.Get(); } inline void DropUserMappingStmt::_internal_set_servername(const std::string& value) { _impl_.servername_.Set(value, GetArenaForAllocation()); } inline std::string* DropUserMappingStmt::_internal_mutable_servername() { return _impl_.servername_.Mutable(GetArenaForAllocation()); } inline std::string* DropUserMappingStmt::release_servername() { // @@protoc_insertion_point(field_release:pg_query.DropUserMappingStmt.servername) return _impl_.servername_.Release(); } inline void DropUserMappingStmt::set_allocated_servername(std::string* servername) { if (servername != nullptr) { } else { } _impl_.servername_.SetAllocated(servername, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.servername_.IsDefault()) { _impl_.servername_.Set("", GetArenaForAllocation()); } #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() { _impl_.missing_ok_ = false; } inline bool DropUserMappingStmt::_internal_missing_ok() const { return _impl_.missing_ok_; } inline bool DropUserMappingStmt::missing_ok() const { // @@protoc_insertion_point(field_get:pg_query.DropUserMappingStmt.missing_ok) return _internal_missing_ok(); } inline void DropUserMappingStmt::_internal_set_missing_ok(bool value) { _impl_.missing_ok_ = value; } inline void DropUserMappingStmt::set_missing_ok(bool value) { _internal_set_missing_ok(value); // @@protoc_insertion_point(field_set:pg_query.DropUserMappingStmt.missing_ok) } // ------------------------------------------------------------------- // AlterTableSpaceOptionsStmt // string tablespacename = 1 [json_name = "tablespacename"]; inline void AlterTableSpaceOptionsStmt::clear_tablespacename() { _impl_.tablespacename_.ClearToEmpty(); } inline const std::string& AlterTableSpaceOptionsStmt::tablespacename() const { // @@protoc_insertion_point(field_get:pg_query.AlterTableSpaceOptionsStmt.tablespacename) return _internal_tablespacename(); } template inline PROTOBUF_ALWAYS_INLINE void AlterTableSpaceOptionsStmt::set_tablespacename(ArgT0&& arg0, ArgT... args) { _impl_.tablespacename_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.AlterTableSpaceOptionsStmt.tablespacename) } inline std::string* AlterTableSpaceOptionsStmt::mutable_tablespacename() { 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 { return _impl_.tablespacename_.Get(); } inline void AlterTableSpaceOptionsStmt::_internal_set_tablespacename(const std::string& value) { _impl_.tablespacename_.Set(value, GetArenaForAllocation()); } inline std::string* AlterTableSpaceOptionsStmt::_internal_mutable_tablespacename() { return _impl_.tablespacename_.Mutable(GetArenaForAllocation()); } inline std::string* AlterTableSpaceOptionsStmt::release_tablespacename() { // @@protoc_insertion_point(field_release:pg_query.AlterTableSpaceOptionsStmt.tablespacename) return _impl_.tablespacename_.Release(); } inline void AlterTableSpaceOptionsStmt::set_allocated_tablespacename(std::string* tablespacename) { if (tablespacename != nullptr) { } else { } _impl_.tablespacename_.SetAllocated(tablespacename, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.tablespacename_.IsDefault()) { _impl_.tablespacename_.Set("", GetArenaForAllocation()); } #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 _impl_.options_.size(); } inline int AlterTableSpaceOptionsStmt::options_size() const { return _internal_options_size(); } inline void AlterTableSpaceOptionsStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* AlterTableSpaceOptionsStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterTableSpaceOptionsStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterTableSpaceOptionsStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTableSpaceOptionsStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& AlterTableSpaceOptionsStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& AlterTableSpaceOptionsStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterTableSpaceOptionsStmt.options) return _internal_options(index); } inline ::pg_query::Node* AlterTableSpaceOptionsStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* AlterTableSpaceOptionsStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.AlterTableSpaceOptionsStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterTableSpaceOptionsStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.AlterTableSpaceOptionsStmt.options) return _impl_.options_; } // bool is_reset = 3 [json_name = "isReset"]; inline void AlterTableSpaceOptionsStmt::clear_is_reset() { _impl_.is_reset_ = false; } inline bool AlterTableSpaceOptionsStmt::_internal_is_reset() const { return _impl_.is_reset_; } inline bool AlterTableSpaceOptionsStmt::is_reset() const { // @@protoc_insertion_point(field_get:pg_query.AlterTableSpaceOptionsStmt.is_reset) return _internal_is_reset(); } inline void AlterTableSpaceOptionsStmt::_internal_set_is_reset(bool value) { _impl_.is_reset_ = value; } inline void AlterTableSpaceOptionsStmt::set_is_reset(bool value) { _internal_set_is_reset(value); // @@protoc_insertion_point(field_set:pg_query.AlterTableSpaceOptionsStmt.is_reset) } // ------------------------------------------------------------------- // AlterTableMoveAllStmt // string orig_tablespacename = 1 [json_name = "orig_tablespacename"]; inline void AlterTableMoveAllStmt::clear_orig_tablespacename() { _impl_.orig_tablespacename_.ClearToEmpty(); } inline const std::string& AlterTableMoveAllStmt::orig_tablespacename() const { // @@protoc_insertion_point(field_get:pg_query.AlterTableMoveAllStmt.orig_tablespacename) return _internal_orig_tablespacename(); } template inline PROTOBUF_ALWAYS_INLINE void AlterTableMoveAllStmt::set_orig_tablespacename(ArgT0&& arg0, ArgT... args) { _impl_.orig_tablespacename_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.AlterTableMoveAllStmt.orig_tablespacename) } inline std::string* AlterTableMoveAllStmt::mutable_orig_tablespacename() { 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 { return _impl_.orig_tablespacename_.Get(); } inline void AlterTableMoveAllStmt::_internal_set_orig_tablespacename(const std::string& value) { _impl_.orig_tablespacename_.Set(value, GetArenaForAllocation()); } inline std::string* AlterTableMoveAllStmt::_internal_mutable_orig_tablespacename() { return _impl_.orig_tablespacename_.Mutable(GetArenaForAllocation()); } inline std::string* AlterTableMoveAllStmt::release_orig_tablespacename() { // @@protoc_insertion_point(field_release:pg_query.AlterTableMoveAllStmt.orig_tablespacename) return _impl_.orig_tablespacename_.Release(); } inline void AlterTableMoveAllStmt::set_allocated_orig_tablespacename(std::string* orig_tablespacename) { if (orig_tablespacename != nullptr) { } else { } _impl_.orig_tablespacename_.SetAllocated(orig_tablespacename, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.orig_tablespacename_.IsDefault()) { _impl_.orig_tablespacename_.Set("", GetArenaForAllocation()); } #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() { _impl_.objtype_ = 0; } inline ::pg_query::ObjectType AlterTableMoveAllStmt::_internal_objtype() const { return static_cast< ::pg_query::ObjectType >(_impl_.objtype_); } inline ::pg_query::ObjectType AlterTableMoveAllStmt::objtype() const { // @@protoc_insertion_point(field_get:pg_query.AlterTableMoveAllStmt.objtype) return _internal_objtype(); } inline void AlterTableMoveAllStmt::_internal_set_objtype(::pg_query::ObjectType value) { _impl_.objtype_ = value; } inline void AlterTableMoveAllStmt::set_objtype(::pg_query::ObjectType value) { _internal_set_objtype(value); // @@protoc_insertion_point(field_set:pg_query.AlterTableMoveAllStmt.objtype) } // repeated .pg_query.Node roles = 3 [json_name = "roles"]; inline int AlterTableMoveAllStmt::_internal_roles_size() const { return _impl_.roles_.size(); } inline int AlterTableMoveAllStmt::roles_size() const { return _internal_roles_size(); } inline void AlterTableMoveAllStmt::clear_roles() { _impl_.roles_.Clear(); } inline ::pg_query::Node* AlterTableMoveAllStmt::mutable_roles(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterTableMoveAllStmt.roles) return _impl_.roles_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterTableMoveAllStmt::mutable_roles() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterTableMoveAllStmt.roles) return &_impl_.roles_; } inline const ::pg_query::Node& AlterTableMoveAllStmt::_internal_roles(int index) const { return _impl_.roles_.Get(index); } inline const ::pg_query::Node& AlterTableMoveAllStmt::roles(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterTableMoveAllStmt.roles) return _internal_roles(index); } inline ::pg_query::Node* AlterTableMoveAllStmt::_internal_add_roles() { return _impl_.roles_.Add(); } inline ::pg_query::Node* AlterTableMoveAllStmt::add_roles() { ::pg_query::Node* _add = _internal_add_roles(); // @@protoc_insertion_point(field_add:pg_query.AlterTableMoveAllStmt.roles) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterTableMoveAllStmt::roles() const { // @@protoc_insertion_point(field_list:pg_query.AlterTableMoveAllStmt.roles) return _impl_.roles_; } // string new_tablespacename = 4 [json_name = "new_tablespacename"]; inline void AlterTableMoveAllStmt::clear_new_tablespacename() { _impl_.new_tablespacename_.ClearToEmpty(); } inline const std::string& AlterTableMoveAllStmt::new_tablespacename() const { // @@protoc_insertion_point(field_get:pg_query.AlterTableMoveAllStmt.new_tablespacename) return _internal_new_tablespacename(); } template inline PROTOBUF_ALWAYS_INLINE void AlterTableMoveAllStmt::set_new_tablespacename(ArgT0&& arg0, ArgT... args) { _impl_.new_tablespacename_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.AlterTableMoveAllStmt.new_tablespacename) } inline std::string* AlterTableMoveAllStmt::mutable_new_tablespacename() { 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 { return _impl_.new_tablespacename_.Get(); } inline void AlterTableMoveAllStmt::_internal_set_new_tablespacename(const std::string& value) { _impl_.new_tablespacename_.Set(value, GetArenaForAllocation()); } inline std::string* AlterTableMoveAllStmt::_internal_mutable_new_tablespacename() { return _impl_.new_tablespacename_.Mutable(GetArenaForAllocation()); } inline std::string* AlterTableMoveAllStmt::release_new_tablespacename() { // @@protoc_insertion_point(field_release:pg_query.AlterTableMoveAllStmt.new_tablespacename) return _impl_.new_tablespacename_.Release(); } inline void AlterTableMoveAllStmt::set_allocated_new_tablespacename(std::string* new_tablespacename) { if (new_tablespacename != nullptr) { } else { } _impl_.new_tablespacename_.SetAllocated(new_tablespacename, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.new_tablespacename_.IsDefault()) { _impl_.new_tablespacename_.Set("", GetArenaForAllocation()); } #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() { _impl_.nowait_ = false; } inline bool AlterTableMoveAllStmt::_internal_nowait() const { return _impl_.nowait_; } inline bool AlterTableMoveAllStmt::nowait() const { // @@protoc_insertion_point(field_get:pg_query.AlterTableMoveAllStmt.nowait) return _internal_nowait(); } inline void AlterTableMoveAllStmt::_internal_set_nowait(bool value) { _impl_.nowait_ = value; } inline void AlterTableMoveAllStmt::set_nowait(bool value) { _internal_set_nowait(value); // @@protoc_insertion_point(field_set:pg_query.AlterTableMoveAllStmt.nowait) } // ------------------------------------------------------------------- // SecLabelStmt // .pg_query.ObjectType objtype = 1 [json_name = "objtype"]; inline void SecLabelStmt::clear_objtype() { _impl_.objtype_ = 0; } inline ::pg_query::ObjectType SecLabelStmt::_internal_objtype() const { return static_cast< ::pg_query::ObjectType >(_impl_.objtype_); } inline ::pg_query::ObjectType SecLabelStmt::objtype() const { // @@protoc_insertion_point(field_get:pg_query.SecLabelStmt.objtype) return _internal_objtype(); } inline void SecLabelStmt::_internal_set_objtype(::pg_query::ObjectType value) { _impl_.objtype_ = value; } inline void SecLabelStmt::set_objtype(::pg_query::ObjectType value) { _internal_set_objtype(value); // @@protoc_insertion_point(field_set:pg_query.SecLabelStmt.objtype) } // .pg_query.Node object = 2 [json_name = "object"]; inline bool SecLabelStmt::_internal_has_object() const { return this != internal_default_instance() && _impl_.object_ != nullptr; } inline bool SecLabelStmt::has_object() const { return _internal_has_object(); } inline void SecLabelStmt::clear_object() { if (GetArenaForAllocation() == nullptr && _impl_.object_ != nullptr) { delete _impl_.object_; } _impl_.object_ = nullptr; } inline const ::pg_query::Node& SecLabelStmt::_internal_object() const { const ::pg_query::Node* p = _impl_.object_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& SecLabelStmt::object() const { // @@protoc_insertion_point(field_get:pg_query.SecLabelStmt.object) return _internal_object(); } inline void SecLabelStmt::unsafe_arena_set_allocated_object( ::pg_query::Node* object) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.object_); } _impl_.object_ = object; if (object) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SecLabelStmt.object) } inline ::pg_query::Node* SecLabelStmt::release_object() { ::pg_query::Node* temp = _impl_.object_; _impl_.object_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* SecLabelStmt::unsafe_arena_release_object() { // @@protoc_insertion_point(field_release:pg_query.SecLabelStmt.object) ::pg_query::Node* temp = _impl_.object_; _impl_.object_ = nullptr; return temp; } inline ::pg_query::Node* SecLabelStmt::_internal_mutable_object() { if (_impl_.object_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.object_ = p; } return _impl_.object_; } inline ::pg_query::Node* SecLabelStmt::mutable_object() { ::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* object) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.object_; } if (object) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(object); if (message_arena != submessage_arena) { object = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, object, submessage_arena); } } else { } _impl_.object_ = object; // @@protoc_insertion_point(field_set_allocated:pg_query.SecLabelStmt.object) } // string provider = 3 [json_name = "provider"]; inline void SecLabelStmt::clear_provider() { _impl_.provider_.ClearToEmpty(); } inline const std::string& SecLabelStmt::provider() const { // @@protoc_insertion_point(field_get:pg_query.SecLabelStmt.provider) return _internal_provider(); } template inline PROTOBUF_ALWAYS_INLINE void SecLabelStmt::set_provider(ArgT0&& arg0, ArgT... args) { _impl_.provider_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.SecLabelStmt.provider) } inline std::string* SecLabelStmt::mutable_provider() { 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 { return _impl_.provider_.Get(); } inline void SecLabelStmt::_internal_set_provider(const std::string& value) { _impl_.provider_.Set(value, GetArenaForAllocation()); } inline std::string* SecLabelStmt::_internal_mutable_provider() { return _impl_.provider_.Mutable(GetArenaForAllocation()); } inline std::string* SecLabelStmt::release_provider() { // @@protoc_insertion_point(field_release:pg_query.SecLabelStmt.provider) return _impl_.provider_.Release(); } inline void SecLabelStmt::set_allocated_provider(std::string* provider) { if (provider != nullptr) { } else { } _impl_.provider_.SetAllocated(provider, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.provider_.IsDefault()) { _impl_.provider_.Set("", GetArenaForAllocation()); } #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() { _impl_.label_.ClearToEmpty(); } inline const std::string& SecLabelStmt::label() const { // @@protoc_insertion_point(field_get:pg_query.SecLabelStmt.label) return _internal_label(); } template inline PROTOBUF_ALWAYS_INLINE void SecLabelStmt::set_label(ArgT0&& arg0, ArgT... args) { _impl_.label_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.SecLabelStmt.label) } inline std::string* SecLabelStmt::mutable_label() { 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 { return _impl_.label_.Get(); } inline void SecLabelStmt::_internal_set_label(const std::string& value) { _impl_.label_.Set(value, GetArenaForAllocation()); } inline std::string* SecLabelStmt::_internal_mutable_label() { return _impl_.label_.Mutable(GetArenaForAllocation()); } inline std::string* SecLabelStmt::release_label() { // @@protoc_insertion_point(field_release:pg_query.SecLabelStmt.label) return _impl_.label_.Release(); } inline void SecLabelStmt::set_allocated_label(std::string* label) { if (label != nullptr) { } else { } _impl_.label_.SetAllocated(label, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.label_.IsDefault()) { _impl_.label_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:pg_query.SecLabelStmt.label) } // ------------------------------------------------------------------- // CreateForeignTableStmt // .pg_query.CreateStmt base_stmt = 1 [json_name = "base"]; inline bool CreateForeignTableStmt::_internal_has_base_stmt() const { return this != internal_default_instance() && _impl_.base_stmt_ != nullptr; } inline bool CreateForeignTableStmt::has_base_stmt() const { return _internal_has_base_stmt(); } inline void CreateForeignTableStmt::clear_base_stmt() { if (GetArenaForAllocation() == nullptr && _impl_.base_stmt_ != nullptr) { delete _impl_.base_stmt_; } _impl_.base_stmt_ = nullptr; } inline const ::pg_query::CreateStmt& CreateForeignTableStmt::_internal_base_stmt() const { const ::pg_query::CreateStmt* p = _impl_.base_stmt_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_CreateStmt_default_instance_); } inline const ::pg_query::CreateStmt& CreateForeignTableStmt::base_stmt() const { // @@protoc_insertion_point(field_get:pg_query.CreateForeignTableStmt.base_stmt) return _internal_base_stmt(); } inline void CreateForeignTableStmt::unsafe_arena_set_allocated_base_stmt( ::pg_query::CreateStmt* base_stmt) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.base_stmt_); } _impl_.base_stmt_ = base_stmt; if (base_stmt) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateForeignTableStmt.base_stmt) } inline ::pg_query::CreateStmt* CreateForeignTableStmt::release_base_stmt() { ::pg_query::CreateStmt* temp = _impl_.base_stmt_; _impl_.base_stmt_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::CreateStmt* CreateForeignTableStmt::unsafe_arena_release_base_stmt() { // @@protoc_insertion_point(field_release:pg_query.CreateForeignTableStmt.base_stmt) ::pg_query::CreateStmt* temp = _impl_.base_stmt_; _impl_.base_stmt_ = nullptr; return temp; } inline ::pg_query::CreateStmt* CreateForeignTableStmt::_internal_mutable_base_stmt() { if (_impl_.base_stmt_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::CreateStmt>(GetArenaForAllocation()); _impl_.base_stmt_ = p; } return _impl_.base_stmt_; } inline ::pg_query::CreateStmt* CreateForeignTableStmt::mutable_base_stmt() { ::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* base_stmt) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.base_stmt_; } if (base_stmt) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(base_stmt); if (message_arena != submessage_arena) { base_stmt = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, base_stmt, submessage_arena); } } else { } _impl_.base_stmt_ = base_stmt; // @@protoc_insertion_point(field_set_allocated:pg_query.CreateForeignTableStmt.base_stmt) } // string servername = 2 [json_name = "servername"]; inline void CreateForeignTableStmt::clear_servername() { _impl_.servername_.ClearToEmpty(); } inline const std::string& CreateForeignTableStmt::servername() const { // @@protoc_insertion_point(field_get:pg_query.CreateForeignTableStmt.servername) return _internal_servername(); } template inline PROTOBUF_ALWAYS_INLINE void CreateForeignTableStmt::set_servername(ArgT0&& arg0, ArgT... args) { _impl_.servername_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreateForeignTableStmt.servername) } inline std::string* CreateForeignTableStmt::mutable_servername() { 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 { return _impl_.servername_.Get(); } inline void CreateForeignTableStmt::_internal_set_servername(const std::string& value) { _impl_.servername_.Set(value, GetArenaForAllocation()); } inline std::string* CreateForeignTableStmt::_internal_mutable_servername() { return _impl_.servername_.Mutable(GetArenaForAllocation()); } inline std::string* CreateForeignTableStmt::release_servername() { // @@protoc_insertion_point(field_release:pg_query.CreateForeignTableStmt.servername) return _impl_.servername_.Release(); } inline void CreateForeignTableStmt::set_allocated_servername(std::string* servername) { if (servername != nullptr) { } else { } _impl_.servername_.SetAllocated(servername, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.servername_.IsDefault()) { _impl_.servername_.Set("", GetArenaForAllocation()); } #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 _impl_.options_.size(); } inline int CreateForeignTableStmt::options_size() const { return _internal_options_size(); } inline void CreateForeignTableStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* CreateForeignTableStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateForeignTableStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateForeignTableStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateForeignTableStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& CreateForeignTableStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& CreateForeignTableStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateForeignTableStmt.options) return _internal_options(index); } inline ::pg_query::Node* CreateForeignTableStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* CreateForeignTableStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.CreateForeignTableStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateForeignTableStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.CreateForeignTableStmt.options) return _impl_.options_; } // ------------------------------------------------------------------- // ImportForeignSchemaStmt // string server_name = 1 [json_name = "server_name"]; inline void ImportForeignSchemaStmt::clear_server_name() { _impl_.server_name_.ClearToEmpty(); } inline const std::string& ImportForeignSchemaStmt::server_name() const { // @@protoc_insertion_point(field_get:pg_query.ImportForeignSchemaStmt.server_name) return _internal_server_name(); } template inline PROTOBUF_ALWAYS_INLINE void ImportForeignSchemaStmt::set_server_name(ArgT0&& arg0, ArgT... args) { _impl_.server_name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.ImportForeignSchemaStmt.server_name) } inline std::string* ImportForeignSchemaStmt::mutable_server_name() { 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 { return _impl_.server_name_.Get(); } inline void ImportForeignSchemaStmt::_internal_set_server_name(const std::string& value) { _impl_.server_name_.Set(value, GetArenaForAllocation()); } inline std::string* ImportForeignSchemaStmt::_internal_mutable_server_name() { return _impl_.server_name_.Mutable(GetArenaForAllocation()); } inline std::string* ImportForeignSchemaStmt::release_server_name() { // @@protoc_insertion_point(field_release:pg_query.ImportForeignSchemaStmt.server_name) return _impl_.server_name_.Release(); } inline void ImportForeignSchemaStmt::set_allocated_server_name(std::string* server_name) { if (server_name != nullptr) { } else { } _impl_.server_name_.SetAllocated(server_name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.server_name_.IsDefault()) { _impl_.server_name_.Set("", GetArenaForAllocation()); } #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() { _impl_.remote_schema_.ClearToEmpty(); } inline const std::string& ImportForeignSchemaStmt::remote_schema() const { // @@protoc_insertion_point(field_get:pg_query.ImportForeignSchemaStmt.remote_schema) return _internal_remote_schema(); } template inline PROTOBUF_ALWAYS_INLINE void ImportForeignSchemaStmt::set_remote_schema(ArgT0&& arg0, ArgT... args) { _impl_.remote_schema_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.ImportForeignSchemaStmt.remote_schema) } inline std::string* ImportForeignSchemaStmt::mutable_remote_schema() { 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 { return _impl_.remote_schema_.Get(); } inline void ImportForeignSchemaStmt::_internal_set_remote_schema(const std::string& value) { _impl_.remote_schema_.Set(value, GetArenaForAllocation()); } inline std::string* ImportForeignSchemaStmt::_internal_mutable_remote_schema() { return _impl_.remote_schema_.Mutable(GetArenaForAllocation()); } inline std::string* ImportForeignSchemaStmt::release_remote_schema() { // @@protoc_insertion_point(field_release:pg_query.ImportForeignSchemaStmt.remote_schema) return _impl_.remote_schema_.Release(); } inline void ImportForeignSchemaStmt::set_allocated_remote_schema(std::string* remote_schema) { if (remote_schema != nullptr) { } else { } _impl_.remote_schema_.SetAllocated(remote_schema, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.remote_schema_.IsDefault()) { _impl_.remote_schema_.Set("", GetArenaForAllocation()); } #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() { _impl_.local_schema_.ClearToEmpty(); } inline const std::string& ImportForeignSchemaStmt::local_schema() const { // @@protoc_insertion_point(field_get:pg_query.ImportForeignSchemaStmt.local_schema) return _internal_local_schema(); } template inline PROTOBUF_ALWAYS_INLINE void ImportForeignSchemaStmt::set_local_schema(ArgT0&& arg0, ArgT... args) { _impl_.local_schema_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.ImportForeignSchemaStmt.local_schema) } inline std::string* ImportForeignSchemaStmt::mutable_local_schema() { 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 { return _impl_.local_schema_.Get(); } inline void ImportForeignSchemaStmt::_internal_set_local_schema(const std::string& value) { _impl_.local_schema_.Set(value, GetArenaForAllocation()); } inline std::string* ImportForeignSchemaStmt::_internal_mutable_local_schema() { return _impl_.local_schema_.Mutable(GetArenaForAllocation()); } inline std::string* ImportForeignSchemaStmt::release_local_schema() { // @@protoc_insertion_point(field_release:pg_query.ImportForeignSchemaStmt.local_schema) return _impl_.local_schema_.Release(); } inline void ImportForeignSchemaStmt::set_allocated_local_schema(std::string* local_schema) { if (local_schema != nullptr) { } else { } _impl_.local_schema_.SetAllocated(local_schema, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.local_schema_.IsDefault()) { _impl_.local_schema_.Set("", GetArenaForAllocation()); } #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() { _impl_.list_type_ = 0; } inline ::pg_query::ImportForeignSchemaType ImportForeignSchemaStmt::_internal_list_type() const { return static_cast< ::pg_query::ImportForeignSchemaType >(_impl_.list_type_); } inline ::pg_query::ImportForeignSchemaType ImportForeignSchemaStmt::list_type() const { // @@protoc_insertion_point(field_get:pg_query.ImportForeignSchemaStmt.list_type) return _internal_list_type(); } inline void ImportForeignSchemaStmt::_internal_set_list_type(::pg_query::ImportForeignSchemaType value) { _impl_.list_type_ = value; } inline void ImportForeignSchemaStmt::set_list_type(::pg_query::ImportForeignSchemaType value) { _internal_set_list_type(value); // @@protoc_insertion_point(field_set:pg_query.ImportForeignSchemaStmt.list_type) } // repeated .pg_query.Node table_list = 5 [json_name = "table_list"]; inline int ImportForeignSchemaStmt::_internal_table_list_size() const { return _impl_.table_list_.size(); } inline int ImportForeignSchemaStmt::table_list_size() const { return _internal_table_list_size(); } inline void ImportForeignSchemaStmt::clear_table_list() { _impl_.table_list_.Clear(); } inline ::pg_query::Node* ImportForeignSchemaStmt::mutable_table_list(int index) { // @@protoc_insertion_point(field_mutable:pg_query.ImportForeignSchemaStmt.table_list) return _impl_.table_list_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* ImportForeignSchemaStmt::mutable_table_list() { // @@protoc_insertion_point(field_mutable_list:pg_query.ImportForeignSchemaStmt.table_list) return &_impl_.table_list_; } inline const ::pg_query::Node& ImportForeignSchemaStmt::_internal_table_list(int index) const { return _impl_.table_list_.Get(index); } inline const ::pg_query::Node& ImportForeignSchemaStmt::table_list(int index) const { // @@protoc_insertion_point(field_get:pg_query.ImportForeignSchemaStmt.table_list) return _internal_table_list(index); } inline ::pg_query::Node* ImportForeignSchemaStmt::_internal_add_table_list() { return _impl_.table_list_.Add(); } inline ::pg_query::Node* ImportForeignSchemaStmt::add_table_list() { ::pg_query::Node* _add = _internal_add_table_list(); // @@protoc_insertion_point(field_add:pg_query.ImportForeignSchemaStmt.table_list) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& ImportForeignSchemaStmt::table_list() const { // @@protoc_insertion_point(field_list:pg_query.ImportForeignSchemaStmt.table_list) return _impl_.table_list_; } // repeated .pg_query.Node options = 6 [json_name = "options"]; inline int ImportForeignSchemaStmt::_internal_options_size() const { return _impl_.options_.size(); } inline int ImportForeignSchemaStmt::options_size() const { return _internal_options_size(); } inline void ImportForeignSchemaStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* ImportForeignSchemaStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.ImportForeignSchemaStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* ImportForeignSchemaStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.ImportForeignSchemaStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& ImportForeignSchemaStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& ImportForeignSchemaStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.ImportForeignSchemaStmt.options) return _internal_options(index); } inline ::pg_query::Node* ImportForeignSchemaStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* ImportForeignSchemaStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.ImportForeignSchemaStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& ImportForeignSchemaStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.ImportForeignSchemaStmt.options) return _impl_.options_; } // ------------------------------------------------------------------- // CreateExtensionStmt // string extname = 1 [json_name = "extname"]; inline void CreateExtensionStmt::clear_extname() { _impl_.extname_.ClearToEmpty(); } inline const std::string& CreateExtensionStmt::extname() const { // @@protoc_insertion_point(field_get:pg_query.CreateExtensionStmt.extname) return _internal_extname(); } template inline PROTOBUF_ALWAYS_INLINE void CreateExtensionStmt::set_extname(ArgT0&& arg0, ArgT... args) { _impl_.extname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreateExtensionStmt.extname) } inline std::string* CreateExtensionStmt::mutable_extname() { 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 { return _impl_.extname_.Get(); } inline void CreateExtensionStmt::_internal_set_extname(const std::string& value) { _impl_.extname_.Set(value, GetArenaForAllocation()); } inline std::string* CreateExtensionStmt::_internal_mutable_extname() { return _impl_.extname_.Mutable(GetArenaForAllocation()); } inline std::string* CreateExtensionStmt::release_extname() { // @@protoc_insertion_point(field_release:pg_query.CreateExtensionStmt.extname) return _impl_.extname_.Release(); } inline void CreateExtensionStmt::set_allocated_extname(std::string* extname) { if (extname != nullptr) { } else { } _impl_.extname_.SetAllocated(extname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.extname_.IsDefault()) { _impl_.extname_.Set("", GetArenaForAllocation()); } #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() { _impl_.if_not_exists_ = false; } inline bool CreateExtensionStmt::_internal_if_not_exists() const { return _impl_.if_not_exists_; } inline bool CreateExtensionStmt::if_not_exists() const { // @@protoc_insertion_point(field_get:pg_query.CreateExtensionStmt.if_not_exists) return _internal_if_not_exists(); } inline void CreateExtensionStmt::_internal_set_if_not_exists(bool value) { _impl_.if_not_exists_ = value; } inline void CreateExtensionStmt::set_if_not_exists(bool value) { _internal_set_if_not_exists(value); // @@protoc_insertion_point(field_set:pg_query.CreateExtensionStmt.if_not_exists) } // repeated .pg_query.Node options = 3 [json_name = "options"]; inline int CreateExtensionStmt::_internal_options_size() const { return _impl_.options_.size(); } inline int CreateExtensionStmt::options_size() const { return _internal_options_size(); } inline void CreateExtensionStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* CreateExtensionStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateExtensionStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateExtensionStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateExtensionStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& CreateExtensionStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& CreateExtensionStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateExtensionStmt.options) return _internal_options(index); } inline ::pg_query::Node* CreateExtensionStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* CreateExtensionStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.CreateExtensionStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateExtensionStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.CreateExtensionStmt.options) return _impl_.options_; } // ------------------------------------------------------------------- // AlterExtensionStmt // string extname = 1 [json_name = "extname"]; inline void AlterExtensionStmt::clear_extname() { _impl_.extname_.ClearToEmpty(); } inline const std::string& AlterExtensionStmt::extname() const { // @@protoc_insertion_point(field_get:pg_query.AlterExtensionStmt.extname) return _internal_extname(); } template inline PROTOBUF_ALWAYS_INLINE void AlterExtensionStmt::set_extname(ArgT0&& arg0, ArgT... args) { _impl_.extname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.AlterExtensionStmt.extname) } inline std::string* AlterExtensionStmt::mutable_extname() { 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 { return _impl_.extname_.Get(); } inline void AlterExtensionStmt::_internal_set_extname(const std::string& value) { _impl_.extname_.Set(value, GetArenaForAllocation()); } inline std::string* AlterExtensionStmt::_internal_mutable_extname() { return _impl_.extname_.Mutable(GetArenaForAllocation()); } inline std::string* AlterExtensionStmt::release_extname() { // @@protoc_insertion_point(field_release:pg_query.AlterExtensionStmt.extname) return _impl_.extname_.Release(); } inline void AlterExtensionStmt::set_allocated_extname(std::string* extname) { if (extname != nullptr) { } else { } _impl_.extname_.SetAllocated(extname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.extname_.IsDefault()) { _impl_.extname_.Set("", GetArenaForAllocation()); } #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 _impl_.options_.size(); } inline int AlterExtensionStmt::options_size() const { return _internal_options_size(); } inline void AlterExtensionStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* AlterExtensionStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterExtensionStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterExtensionStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterExtensionStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& AlterExtensionStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& AlterExtensionStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterExtensionStmt.options) return _internal_options(index); } inline ::pg_query::Node* AlterExtensionStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* AlterExtensionStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.AlterExtensionStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterExtensionStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.AlterExtensionStmt.options) return _impl_.options_; } // ------------------------------------------------------------------- // AlterExtensionContentsStmt // string extname = 1 [json_name = "extname"]; inline void AlterExtensionContentsStmt::clear_extname() { _impl_.extname_.ClearToEmpty(); } inline const std::string& AlterExtensionContentsStmt::extname() const { // @@protoc_insertion_point(field_get:pg_query.AlterExtensionContentsStmt.extname) return _internal_extname(); } template inline PROTOBUF_ALWAYS_INLINE void AlterExtensionContentsStmt::set_extname(ArgT0&& arg0, ArgT... args) { _impl_.extname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.AlterExtensionContentsStmt.extname) } inline std::string* AlterExtensionContentsStmt::mutable_extname() { 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 { return _impl_.extname_.Get(); } inline void AlterExtensionContentsStmt::_internal_set_extname(const std::string& value) { _impl_.extname_.Set(value, GetArenaForAllocation()); } inline std::string* AlterExtensionContentsStmt::_internal_mutable_extname() { return _impl_.extname_.Mutable(GetArenaForAllocation()); } inline std::string* AlterExtensionContentsStmt::release_extname() { // @@protoc_insertion_point(field_release:pg_query.AlterExtensionContentsStmt.extname) return _impl_.extname_.Release(); } inline void AlterExtensionContentsStmt::set_allocated_extname(std::string* extname) { if (extname != nullptr) { } else { } _impl_.extname_.SetAllocated(extname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.extname_.IsDefault()) { _impl_.extname_.Set("", GetArenaForAllocation()); } #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() { _impl_.action_ = 0; } inline int32_t AlterExtensionContentsStmt::_internal_action() const { return _impl_.action_; } inline int32_t AlterExtensionContentsStmt::action() const { // @@protoc_insertion_point(field_get:pg_query.AlterExtensionContentsStmt.action) return _internal_action(); } inline void AlterExtensionContentsStmt::_internal_set_action(int32_t value) { _impl_.action_ = value; } inline void AlterExtensionContentsStmt::set_action(int32_t value) { _internal_set_action(value); // @@protoc_insertion_point(field_set:pg_query.AlterExtensionContentsStmt.action) } // .pg_query.ObjectType objtype = 3 [json_name = "objtype"]; inline void AlterExtensionContentsStmt::clear_objtype() { _impl_.objtype_ = 0; } inline ::pg_query::ObjectType AlterExtensionContentsStmt::_internal_objtype() const { return static_cast< ::pg_query::ObjectType >(_impl_.objtype_); } inline ::pg_query::ObjectType AlterExtensionContentsStmt::objtype() const { // @@protoc_insertion_point(field_get:pg_query.AlterExtensionContentsStmt.objtype) return _internal_objtype(); } inline void AlterExtensionContentsStmt::_internal_set_objtype(::pg_query::ObjectType value) { _impl_.objtype_ = value; } inline void AlterExtensionContentsStmt::set_objtype(::pg_query::ObjectType value) { _internal_set_objtype(value); // @@protoc_insertion_point(field_set:pg_query.AlterExtensionContentsStmt.objtype) } // .pg_query.Node object = 4 [json_name = "object"]; inline bool AlterExtensionContentsStmt::_internal_has_object() const { return this != internal_default_instance() && _impl_.object_ != nullptr; } inline bool AlterExtensionContentsStmt::has_object() const { return _internal_has_object(); } inline void AlterExtensionContentsStmt::clear_object() { if (GetArenaForAllocation() == nullptr && _impl_.object_ != nullptr) { delete _impl_.object_; } _impl_.object_ = nullptr; } inline const ::pg_query::Node& AlterExtensionContentsStmt::_internal_object() const { const ::pg_query::Node* p = _impl_.object_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& AlterExtensionContentsStmt::object() const { // @@protoc_insertion_point(field_get:pg_query.AlterExtensionContentsStmt.object) return _internal_object(); } inline void AlterExtensionContentsStmt::unsafe_arena_set_allocated_object( ::pg_query::Node* object) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.object_); } _impl_.object_ = object; if (object) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterExtensionContentsStmt.object) } inline ::pg_query::Node* AlterExtensionContentsStmt::release_object() { ::pg_query::Node* temp = _impl_.object_; _impl_.object_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* AlterExtensionContentsStmt::unsafe_arena_release_object() { // @@protoc_insertion_point(field_release:pg_query.AlterExtensionContentsStmt.object) ::pg_query::Node* temp = _impl_.object_; _impl_.object_ = nullptr; return temp; } inline ::pg_query::Node* AlterExtensionContentsStmt::_internal_mutable_object() { if (_impl_.object_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.object_ = p; } return _impl_.object_; } inline ::pg_query::Node* AlterExtensionContentsStmt::mutable_object() { ::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* object) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.object_; } if (object) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(object); if (message_arena != submessage_arena) { object = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, object, submessage_arena); } } else { } _impl_.object_ = object; // @@protoc_insertion_point(field_set_allocated:pg_query.AlterExtensionContentsStmt.object) } // ------------------------------------------------------------------- // CreateEventTrigStmt // string trigname = 1 [json_name = "trigname"]; inline void CreateEventTrigStmt::clear_trigname() { _impl_.trigname_.ClearToEmpty(); } inline const std::string& CreateEventTrigStmt::trigname() const { // @@protoc_insertion_point(field_get:pg_query.CreateEventTrigStmt.trigname) return _internal_trigname(); } template inline PROTOBUF_ALWAYS_INLINE void CreateEventTrigStmt::set_trigname(ArgT0&& arg0, ArgT... args) { _impl_.trigname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreateEventTrigStmt.trigname) } inline std::string* CreateEventTrigStmt::mutable_trigname() { 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 { return _impl_.trigname_.Get(); } inline void CreateEventTrigStmt::_internal_set_trigname(const std::string& value) { _impl_.trigname_.Set(value, GetArenaForAllocation()); } inline std::string* CreateEventTrigStmt::_internal_mutable_trigname() { return _impl_.trigname_.Mutable(GetArenaForAllocation()); } inline std::string* CreateEventTrigStmt::release_trigname() { // @@protoc_insertion_point(field_release:pg_query.CreateEventTrigStmt.trigname) return _impl_.trigname_.Release(); } inline void CreateEventTrigStmt::set_allocated_trigname(std::string* trigname) { if (trigname != nullptr) { } else { } _impl_.trigname_.SetAllocated(trigname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.trigname_.IsDefault()) { _impl_.trigname_.Set("", GetArenaForAllocation()); } #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() { _impl_.eventname_.ClearToEmpty(); } inline const std::string& CreateEventTrigStmt::eventname() const { // @@protoc_insertion_point(field_get:pg_query.CreateEventTrigStmt.eventname) return _internal_eventname(); } template inline PROTOBUF_ALWAYS_INLINE void CreateEventTrigStmt::set_eventname(ArgT0&& arg0, ArgT... args) { _impl_.eventname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreateEventTrigStmt.eventname) } inline std::string* CreateEventTrigStmt::mutable_eventname() { 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 { return _impl_.eventname_.Get(); } inline void CreateEventTrigStmt::_internal_set_eventname(const std::string& value) { _impl_.eventname_.Set(value, GetArenaForAllocation()); } inline std::string* CreateEventTrigStmt::_internal_mutable_eventname() { return _impl_.eventname_.Mutable(GetArenaForAllocation()); } inline std::string* CreateEventTrigStmt::release_eventname() { // @@protoc_insertion_point(field_release:pg_query.CreateEventTrigStmt.eventname) return _impl_.eventname_.Release(); } inline void CreateEventTrigStmt::set_allocated_eventname(std::string* eventname) { if (eventname != nullptr) { } else { } _impl_.eventname_.SetAllocated(eventname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.eventname_.IsDefault()) { _impl_.eventname_.Set("", GetArenaForAllocation()); } #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 _impl_.whenclause_.size(); } inline int CreateEventTrigStmt::whenclause_size() const { return _internal_whenclause_size(); } inline void CreateEventTrigStmt::clear_whenclause() { _impl_.whenclause_.Clear(); } inline ::pg_query::Node* CreateEventTrigStmt::mutable_whenclause(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateEventTrigStmt.whenclause) return _impl_.whenclause_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateEventTrigStmt::mutable_whenclause() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateEventTrigStmt.whenclause) return &_impl_.whenclause_; } inline const ::pg_query::Node& CreateEventTrigStmt::_internal_whenclause(int index) const { return _impl_.whenclause_.Get(index); } inline const ::pg_query::Node& CreateEventTrigStmt::whenclause(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateEventTrigStmt.whenclause) return _internal_whenclause(index); } inline ::pg_query::Node* CreateEventTrigStmt::_internal_add_whenclause() { return _impl_.whenclause_.Add(); } inline ::pg_query::Node* CreateEventTrigStmt::add_whenclause() { ::pg_query::Node* _add = _internal_add_whenclause(); // @@protoc_insertion_point(field_add:pg_query.CreateEventTrigStmt.whenclause) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateEventTrigStmt::whenclause() const { // @@protoc_insertion_point(field_list:pg_query.CreateEventTrigStmt.whenclause) return _impl_.whenclause_; } // repeated .pg_query.Node funcname = 4 [json_name = "funcname"]; inline int CreateEventTrigStmt::_internal_funcname_size() const { return _impl_.funcname_.size(); } inline int CreateEventTrigStmt::funcname_size() const { return _internal_funcname_size(); } inline void CreateEventTrigStmt::clear_funcname() { _impl_.funcname_.Clear(); } inline ::pg_query::Node* CreateEventTrigStmt::mutable_funcname(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateEventTrigStmt.funcname) return _impl_.funcname_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateEventTrigStmt::mutable_funcname() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateEventTrigStmt.funcname) return &_impl_.funcname_; } inline const ::pg_query::Node& CreateEventTrigStmt::_internal_funcname(int index) const { return _impl_.funcname_.Get(index); } inline const ::pg_query::Node& CreateEventTrigStmt::funcname(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateEventTrigStmt.funcname) return _internal_funcname(index); } inline ::pg_query::Node* CreateEventTrigStmt::_internal_add_funcname() { return _impl_.funcname_.Add(); } inline ::pg_query::Node* CreateEventTrigStmt::add_funcname() { ::pg_query::Node* _add = _internal_add_funcname(); // @@protoc_insertion_point(field_add:pg_query.CreateEventTrigStmt.funcname) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateEventTrigStmt::funcname() const { // @@protoc_insertion_point(field_list:pg_query.CreateEventTrigStmt.funcname) return _impl_.funcname_; } // ------------------------------------------------------------------- // AlterEventTrigStmt // string trigname = 1 [json_name = "trigname"]; inline void AlterEventTrigStmt::clear_trigname() { _impl_.trigname_.ClearToEmpty(); } inline const std::string& AlterEventTrigStmt::trigname() const { // @@protoc_insertion_point(field_get:pg_query.AlterEventTrigStmt.trigname) return _internal_trigname(); } template inline PROTOBUF_ALWAYS_INLINE void AlterEventTrigStmt::set_trigname(ArgT0&& arg0, ArgT... args) { _impl_.trigname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.AlterEventTrigStmt.trigname) } inline std::string* AlterEventTrigStmt::mutable_trigname() { 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 { return _impl_.trigname_.Get(); } inline void AlterEventTrigStmt::_internal_set_trigname(const std::string& value) { _impl_.trigname_.Set(value, GetArenaForAllocation()); } inline std::string* AlterEventTrigStmt::_internal_mutable_trigname() { return _impl_.trigname_.Mutable(GetArenaForAllocation()); } inline std::string* AlterEventTrigStmt::release_trigname() { // @@protoc_insertion_point(field_release:pg_query.AlterEventTrigStmt.trigname) return _impl_.trigname_.Release(); } inline void AlterEventTrigStmt::set_allocated_trigname(std::string* trigname) { if (trigname != nullptr) { } else { } _impl_.trigname_.SetAllocated(trigname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.trigname_.IsDefault()) { _impl_.trigname_.Set("", GetArenaForAllocation()); } #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() { _impl_.tgenabled_.ClearToEmpty(); } inline const std::string& AlterEventTrigStmt::tgenabled() const { // @@protoc_insertion_point(field_get:pg_query.AlterEventTrigStmt.tgenabled) return _internal_tgenabled(); } template inline PROTOBUF_ALWAYS_INLINE void AlterEventTrigStmt::set_tgenabled(ArgT0&& arg0, ArgT... args) { _impl_.tgenabled_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.AlterEventTrigStmt.tgenabled) } inline std::string* AlterEventTrigStmt::mutable_tgenabled() { 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 { return _impl_.tgenabled_.Get(); } inline void AlterEventTrigStmt::_internal_set_tgenabled(const std::string& value) { _impl_.tgenabled_.Set(value, GetArenaForAllocation()); } inline std::string* AlterEventTrigStmt::_internal_mutable_tgenabled() { return _impl_.tgenabled_.Mutable(GetArenaForAllocation()); } inline std::string* AlterEventTrigStmt::release_tgenabled() { // @@protoc_insertion_point(field_release:pg_query.AlterEventTrigStmt.tgenabled) return _impl_.tgenabled_.Release(); } inline void AlterEventTrigStmt::set_allocated_tgenabled(std::string* tgenabled) { if (tgenabled != nullptr) { } else { } _impl_.tgenabled_.SetAllocated(tgenabled, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.tgenabled_.IsDefault()) { _impl_.tgenabled_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:pg_query.AlterEventTrigStmt.tgenabled) } // ------------------------------------------------------------------- // RefreshMatViewStmt // bool concurrent = 1 [json_name = "concurrent"]; inline void RefreshMatViewStmt::clear_concurrent() { _impl_.concurrent_ = false; } inline bool RefreshMatViewStmt::_internal_concurrent() const { return _impl_.concurrent_; } inline bool RefreshMatViewStmt::concurrent() const { // @@protoc_insertion_point(field_get:pg_query.RefreshMatViewStmt.concurrent) return _internal_concurrent(); } inline void RefreshMatViewStmt::_internal_set_concurrent(bool value) { _impl_.concurrent_ = value; } inline void RefreshMatViewStmt::set_concurrent(bool value) { _internal_set_concurrent(value); // @@protoc_insertion_point(field_set:pg_query.RefreshMatViewStmt.concurrent) } // bool skip_data = 2 [json_name = "skipData"]; inline void RefreshMatViewStmt::clear_skip_data() { _impl_.skip_data_ = false; } inline bool RefreshMatViewStmt::_internal_skip_data() const { return _impl_.skip_data_; } inline bool RefreshMatViewStmt::skip_data() const { // @@protoc_insertion_point(field_get:pg_query.RefreshMatViewStmt.skip_data) return _internal_skip_data(); } inline void RefreshMatViewStmt::_internal_set_skip_data(bool value) { _impl_.skip_data_ = value; } inline void RefreshMatViewStmt::set_skip_data(bool value) { _internal_set_skip_data(value); // @@protoc_insertion_point(field_set:pg_query.RefreshMatViewStmt.skip_data) } // .pg_query.RangeVar relation = 3 [json_name = "relation"]; inline bool RefreshMatViewStmt::_internal_has_relation() const { return this != internal_default_instance() && _impl_.relation_ != nullptr; } inline bool RefreshMatViewStmt::has_relation() const { return _internal_has_relation(); } inline void RefreshMatViewStmt::clear_relation() { if (GetArenaForAllocation() == nullptr && _impl_.relation_ != nullptr) { delete _impl_.relation_; } _impl_.relation_ = nullptr; } inline const ::pg_query::RangeVar& RefreshMatViewStmt::_internal_relation() const { const ::pg_query::RangeVar* p = _impl_.relation_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& RefreshMatViewStmt::relation() const { // @@protoc_insertion_point(field_get:pg_query.RefreshMatViewStmt.relation) return _internal_relation(); } inline void RefreshMatViewStmt::unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.relation_); } _impl_.relation_ = relation; if (relation) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RefreshMatViewStmt.relation) } inline ::pg_query::RangeVar* RefreshMatViewStmt::release_relation() { ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* RefreshMatViewStmt::unsafe_arena_release_relation() { // @@protoc_insertion_point(field_release:pg_query.RefreshMatViewStmt.relation) ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; return temp; } inline ::pg_query::RangeVar* RefreshMatViewStmt::_internal_mutable_relation() { if (_impl_.relation_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.relation_ = p; } return _impl_.relation_; } inline ::pg_query::RangeVar* RefreshMatViewStmt::mutable_relation() { ::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* relation) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.relation_; } if (relation) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(relation); if (message_arena != submessage_arena) { relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, relation, submessage_arena); } } else { } _impl_.relation_ = relation; // @@protoc_insertion_point(field_set_allocated:pg_query.RefreshMatViewStmt.relation) } // ------------------------------------------------------------------- // ReplicaIdentityStmt // string identity_type = 1 [json_name = "identity_type"]; inline void ReplicaIdentityStmt::clear_identity_type() { _impl_.identity_type_.ClearToEmpty(); } inline const std::string& ReplicaIdentityStmt::identity_type() const { // @@protoc_insertion_point(field_get:pg_query.ReplicaIdentityStmt.identity_type) return _internal_identity_type(); } template inline PROTOBUF_ALWAYS_INLINE void ReplicaIdentityStmt::set_identity_type(ArgT0&& arg0, ArgT... args) { _impl_.identity_type_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.ReplicaIdentityStmt.identity_type) } inline std::string* ReplicaIdentityStmt::mutable_identity_type() { 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 { return _impl_.identity_type_.Get(); } inline void ReplicaIdentityStmt::_internal_set_identity_type(const std::string& value) { _impl_.identity_type_.Set(value, GetArenaForAllocation()); } inline std::string* ReplicaIdentityStmt::_internal_mutable_identity_type() { return _impl_.identity_type_.Mutable(GetArenaForAllocation()); } inline std::string* ReplicaIdentityStmt::release_identity_type() { // @@protoc_insertion_point(field_release:pg_query.ReplicaIdentityStmt.identity_type) return _impl_.identity_type_.Release(); } inline void ReplicaIdentityStmt::set_allocated_identity_type(std::string* identity_type) { if (identity_type != nullptr) { } else { } _impl_.identity_type_.SetAllocated(identity_type, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.identity_type_.IsDefault()) { _impl_.identity_type_.Set("", GetArenaForAllocation()); } #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() { _impl_.name_.ClearToEmpty(); } inline const std::string& ReplicaIdentityStmt::name() const { // @@protoc_insertion_point(field_get:pg_query.ReplicaIdentityStmt.name) return _internal_name(); } template inline PROTOBUF_ALWAYS_INLINE void ReplicaIdentityStmt::set_name(ArgT0&& arg0, ArgT... args) { _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.ReplicaIdentityStmt.name) } inline std::string* ReplicaIdentityStmt::mutable_name() { 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 { return _impl_.name_.Get(); } inline void ReplicaIdentityStmt::_internal_set_name(const std::string& value) { _impl_.name_.Set(value, GetArenaForAllocation()); } inline std::string* ReplicaIdentityStmt::_internal_mutable_name() { return _impl_.name_.Mutable(GetArenaForAllocation()); } inline std::string* ReplicaIdentityStmt::release_name() { // @@protoc_insertion_point(field_release:pg_query.ReplicaIdentityStmt.name) return _impl_.name_.Release(); } inline void ReplicaIdentityStmt::set_allocated_name(std::string* name) { if (name != nullptr) { } else { } _impl_.name_.SetAllocated(name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.name_.IsDefault()) { _impl_.name_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:pg_query.ReplicaIdentityStmt.name) } // ------------------------------------------------------------------- // AlterSystemStmt // .pg_query.VariableSetStmt setstmt = 1 [json_name = "setstmt"]; inline bool AlterSystemStmt::_internal_has_setstmt() const { return this != internal_default_instance() && _impl_.setstmt_ != nullptr; } inline bool AlterSystemStmt::has_setstmt() const { return _internal_has_setstmt(); } inline void AlterSystemStmt::clear_setstmt() { if (GetArenaForAllocation() == nullptr && _impl_.setstmt_ != nullptr) { delete _impl_.setstmt_; } _impl_.setstmt_ = nullptr; } inline const ::pg_query::VariableSetStmt& AlterSystemStmt::_internal_setstmt() const { const ::pg_query::VariableSetStmt* p = _impl_.setstmt_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_VariableSetStmt_default_instance_); } inline const ::pg_query::VariableSetStmt& AlterSystemStmt::setstmt() const { // @@protoc_insertion_point(field_get:pg_query.AlterSystemStmt.setstmt) return _internal_setstmt(); } inline void AlterSystemStmt::unsafe_arena_set_allocated_setstmt( ::pg_query::VariableSetStmt* setstmt) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.setstmt_); } _impl_.setstmt_ = setstmt; if (setstmt) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterSystemStmt.setstmt) } inline ::pg_query::VariableSetStmt* AlterSystemStmt::release_setstmt() { ::pg_query::VariableSetStmt* temp = _impl_.setstmt_; _impl_.setstmt_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::VariableSetStmt* AlterSystemStmt::unsafe_arena_release_setstmt() { // @@protoc_insertion_point(field_release:pg_query.AlterSystemStmt.setstmt) ::pg_query::VariableSetStmt* temp = _impl_.setstmt_; _impl_.setstmt_ = nullptr; return temp; } inline ::pg_query::VariableSetStmt* AlterSystemStmt::_internal_mutable_setstmt() { if (_impl_.setstmt_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::VariableSetStmt>(GetArenaForAllocation()); _impl_.setstmt_ = p; } return _impl_.setstmt_; } inline ::pg_query::VariableSetStmt* AlterSystemStmt::mutable_setstmt() { ::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* setstmt) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.setstmt_; } if (setstmt) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(setstmt); if (message_arena != submessage_arena) { setstmt = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, setstmt, submessage_arena); } } else { } _impl_.setstmt_ = setstmt; // @@protoc_insertion_point(field_set_allocated:pg_query.AlterSystemStmt.setstmt) } // ------------------------------------------------------------------- // CreatePolicyStmt // string policy_name = 1 [json_name = "policy_name"]; inline void CreatePolicyStmt::clear_policy_name() { _impl_.policy_name_.ClearToEmpty(); } inline const std::string& CreatePolicyStmt::policy_name() const { // @@protoc_insertion_point(field_get:pg_query.CreatePolicyStmt.policy_name) return _internal_policy_name(); } template inline PROTOBUF_ALWAYS_INLINE void CreatePolicyStmt::set_policy_name(ArgT0&& arg0, ArgT... args) { _impl_.policy_name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreatePolicyStmt.policy_name) } inline std::string* CreatePolicyStmt::mutable_policy_name() { 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 { return _impl_.policy_name_.Get(); } inline void CreatePolicyStmt::_internal_set_policy_name(const std::string& value) { _impl_.policy_name_.Set(value, GetArenaForAllocation()); } inline std::string* CreatePolicyStmt::_internal_mutable_policy_name() { return _impl_.policy_name_.Mutable(GetArenaForAllocation()); } inline std::string* CreatePolicyStmt::release_policy_name() { // @@protoc_insertion_point(field_release:pg_query.CreatePolicyStmt.policy_name) return _impl_.policy_name_.Release(); } inline void CreatePolicyStmt::set_allocated_policy_name(std::string* policy_name) { if (policy_name != nullptr) { } else { } _impl_.policy_name_.SetAllocated(policy_name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.policy_name_.IsDefault()) { _impl_.policy_name_.Set("", GetArenaForAllocation()); } #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::_internal_has_table() const { return this != internal_default_instance() && _impl_.table_ != nullptr; } inline bool CreatePolicyStmt::has_table() const { return _internal_has_table(); } inline void CreatePolicyStmt::clear_table() { if (GetArenaForAllocation() == nullptr && _impl_.table_ != nullptr) { delete _impl_.table_; } _impl_.table_ = nullptr; } inline const ::pg_query::RangeVar& CreatePolicyStmt::_internal_table() const { const ::pg_query::RangeVar* p = _impl_.table_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& CreatePolicyStmt::table() const { // @@protoc_insertion_point(field_get:pg_query.CreatePolicyStmt.table) return _internal_table(); } inline void CreatePolicyStmt::unsafe_arena_set_allocated_table( ::pg_query::RangeVar* table) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.table_); } _impl_.table_ = table; if (table) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreatePolicyStmt.table) } inline ::pg_query::RangeVar* CreatePolicyStmt::release_table() { ::pg_query::RangeVar* temp = _impl_.table_; _impl_.table_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* CreatePolicyStmt::unsafe_arena_release_table() { // @@protoc_insertion_point(field_release:pg_query.CreatePolicyStmt.table) ::pg_query::RangeVar* temp = _impl_.table_; _impl_.table_ = nullptr; return temp; } inline ::pg_query::RangeVar* CreatePolicyStmt::_internal_mutable_table() { if (_impl_.table_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.table_ = p; } return _impl_.table_; } inline ::pg_query::RangeVar* CreatePolicyStmt::mutable_table() { ::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* table) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.table_; } if (table) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(table); if (message_arena != submessage_arena) { table = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, table, submessage_arena); } } else { } _impl_.table_ = table; // @@protoc_insertion_point(field_set_allocated:pg_query.CreatePolicyStmt.table) } // string cmd_name = 3 [json_name = "cmd_name"]; inline void CreatePolicyStmt::clear_cmd_name() { _impl_.cmd_name_.ClearToEmpty(); } inline const std::string& CreatePolicyStmt::cmd_name() const { // @@protoc_insertion_point(field_get:pg_query.CreatePolicyStmt.cmd_name) return _internal_cmd_name(); } template inline PROTOBUF_ALWAYS_INLINE void CreatePolicyStmt::set_cmd_name(ArgT0&& arg0, ArgT... args) { _impl_.cmd_name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreatePolicyStmt.cmd_name) } inline std::string* CreatePolicyStmt::mutable_cmd_name() { 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 { return _impl_.cmd_name_.Get(); } inline void CreatePolicyStmt::_internal_set_cmd_name(const std::string& value) { _impl_.cmd_name_.Set(value, GetArenaForAllocation()); } inline std::string* CreatePolicyStmt::_internal_mutable_cmd_name() { return _impl_.cmd_name_.Mutable(GetArenaForAllocation()); } inline std::string* CreatePolicyStmt::release_cmd_name() { // @@protoc_insertion_point(field_release:pg_query.CreatePolicyStmt.cmd_name) return _impl_.cmd_name_.Release(); } inline void CreatePolicyStmt::set_allocated_cmd_name(std::string* cmd_name) { if (cmd_name != nullptr) { } else { } _impl_.cmd_name_.SetAllocated(cmd_name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.cmd_name_.IsDefault()) { _impl_.cmd_name_.Set("", GetArenaForAllocation()); } #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() { _impl_.permissive_ = false; } inline bool CreatePolicyStmt::_internal_permissive() const { return _impl_.permissive_; } inline bool CreatePolicyStmt::permissive() const { // @@protoc_insertion_point(field_get:pg_query.CreatePolicyStmt.permissive) return _internal_permissive(); } inline void CreatePolicyStmt::_internal_set_permissive(bool value) { _impl_.permissive_ = value; } inline void CreatePolicyStmt::set_permissive(bool value) { _internal_set_permissive(value); // @@protoc_insertion_point(field_set:pg_query.CreatePolicyStmt.permissive) } // repeated .pg_query.Node roles = 5 [json_name = "roles"]; inline int CreatePolicyStmt::_internal_roles_size() const { return _impl_.roles_.size(); } inline int CreatePolicyStmt::roles_size() const { return _internal_roles_size(); } inline void CreatePolicyStmt::clear_roles() { _impl_.roles_.Clear(); } inline ::pg_query::Node* CreatePolicyStmt::mutable_roles(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreatePolicyStmt.roles) return _impl_.roles_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreatePolicyStmt::mutable_roles() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreatePolicyStmt.roles) return &_impl_.roles_; } inline const ::pg_query::Node& CreatePolicyStmt::_internal_roles(int index) const { return _impl_.roles_.Get(index); } inline const ::pg_query::Node& CreatePolicyStmt::roles(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreatePolicyStmt.roles) return _internal_roles(index); } inline ::pg_query::Node* CreatePolicyStmt::_internal_add_roles() { return _impl_.roles_.Add(); } inline ::pg_query::Node* CreatePolicyStmt::add_roles() { ::pg_query::Node* _add = _internal_add_roles(); // @@protoc_insertion_point(field_add:pg_query.CreatePolicyStmt.roles) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreatePolicyStmt::roles() const { // @@protoc_insertion_point(field_list:pg_query.CreatePolicyStmt.roles) return _impl_.roles_; } // .pg_query.Node qual = 6 [json_name = "qual"]; inline bool CreatePolicyStmt::_internal_has_qual() const { return this != internal_default_instance() && _impl_.qual_ != nullptr; } inline bool CreatePolicyStmt::has_qual() const { return _internal_has_qual(); } inline void CreatePolicyStmt::clear_qual() { if (GetArenaForAllocation() == nullptr && _impl_.qual_ != nullptr) { delete _impl_.qual_; } _impl_.qual_ = nullptr; } inline const ::pg_query::Node& CreatePolicyStmt::_internal_qual() const { const ::pg_query::Node* p = _impl_.qual_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& CreatePolicyStmt::qual() const { // @@protoc_insertion_point(field_get:pg_query.CreatePolicyStmt.qual) return _internal_qual(); } inline void CreatePolicyStmt::unsafe_arena_set_allocated_qual( ::pg_query::Node* qual) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.qual_); } _impl_.qual_ = qual; if (qual) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreatePolicyStmt.qual) } inline ::pg_query::Node* CreatePolicyStmt::release_qual() { ::pg_query::Node* temp = _impl_.qual_; _impl_.qual_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* CreatePolicyStmt::unsafe_arena_release_qual() { // @@protoc_insertion_point(field_release:pg_query.CreatePolicyStmt.qual) ::pg_query::Node* temp = _impl_.qual_; _impl_.qual_ = nullptr; return temp; } inline ::pg_query::Node* CreatePolicyStmt::_internal_mutable_qual() { if (_impl_.qual_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.qual_ = p; } return _impl_.qual_; } inline ::pg_query::Node* CreatePolicyStmt::mutable_qual() { ::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* qual) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.qual_; } if (qual) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(qual); if (message_arena != submessage_arena) { qual = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, qual, submessage_arena); } } else { } _impl_.qual_ = qual; // @@protoc_insertion_point(field_set_allocated:pg_query.CreatePolicyStmt.qual) } // .pg_query.Node with_check = 7 [json_name = "with_check"]; inline bool CreatePolicyStmt::_internal_has_with_check() const { return this != internal_default_instance() && _impl_.with_check_ != nullptr; } inline bool CreatePolicyStmt::has_with_check() const { return _internal_has_with_check(); } inline void CreatePolicyStmt::clear_with_check() { if (GetArenaForAllocation() == nullptr && _impl_.with_check_ != nullptr) { delete _impl_.with_check_; } _impl_.with_check_ = nullptr; } inline const ::pg_query::Node& CreatePolicyStmt::_internal_with_check() const { const ::pg_query::Node* p = _impl_.with_check_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& CreatePolicyStmt::with_check() const { // @@protoc_insertion_point(field_get:pg_query.CreatePolicyStmt.with_check) return _internal_with_check(); } inline void CreatePolicyStmt::unsafe_arena_set_allocated_with_check( ::pg_query::Node* with_check) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.with_check_); } _impl_.with_check_ = with_check; if (with_check) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreatePolicyStmt.with_check) } inline ::pg_query::Node* CreatePolicyStmt::release_with_check() { ::pg_query::Node* temp = _impl_.with_check_; _impl_.with_check_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* CreatePolicyStmt::unsafe_arena_release_with_check() { // @@protoc_insertion_point(field_release:pg_query.CreatePolicyStmt.with_check) ::pg_query::Node* temp = _impl_.with_check_; _impl_.with_check_ = nullptr; return temp; } inline ::pg_query::Node* CreatePolicyStmt::_internal_mutable_with_check() { if (_impl_.with_check_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.with_check_ = p; } return _impl_.with_check_; } inline ::pg_query::Node* CreatePolicyStmt::mutable_with_check() { ::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* with_check) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.with_check_; } if (with_check) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(with_check); if (message_arena != submessage_arena) { with_check = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, with_check, submessage_arena); } } else { } _impl_.with_check_ = with_check; // @@protoc_insertion_point(field_set_allocated:pg_query.CreatePolicyStmt.with_check) } // ------------------------------------------------------------------- // AlterPolicyStmt // string policy_name = 1 [json_name = "policy_name"]; inline void AlterPolicyStmt::clear_policy_name() { _impl_.policy_name_.ClearToEmpty(); } inline const std::string& AlterPolicyStmt::policy_name() const { // @@protoc_insertion_point(field_get:pg_query.AlterPolicyStmt.policy_name) return _internal_policy_name(); } template inline PROTOBUF_ALWAYS_INLINE void AlterPolicyStmt::set_policy_name(ArgT0&& arg0, ArgT... args) { _impl_.policy_name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.AlterPolicyStmt.policy_name) } inline std::string* AlterPolicyStmt::mutable_policy_name() { 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 { return _impl_.policy_name_.Get(); } inline void AlterPolicyStmt::_internal_set_policy_name(const std::string& value) { _impl_.policy_name_.Set(value, GetArenaForAllocation()); } inline std::string* AlterPolicyStmt::_internal_mutable_policy_name() { return _impl_.policy_name_.Mutable(GetArenaForAllocation()); } inline std::string* AlterPolicyStmt::release_policy_name() { // @@protoc_insertion_point(field_release:pg_query.AlterPolicyStmt.policy_name) return _impl_.policy_name_.Release(); } inline void AlterPolicyStmt::set_allocated_policy_name(std::string* policy_name) { if (policy_name != nullptr) { } else { } _impl_.policy_name_.SetAllocated(policy_name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.policy_name_.IsDefault()) { _impl_.policy_name_.Set("", GetArenaForAllocation()); } #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::_internal_has_table() const { return this != internal_default_instance() && _impl_.table_ != nullptr; } inline bool AlterPolicyStmt::has_table() const { return _internal_has_table(); } inline void AlterPolicyStmt::clear_table() { if (GetArenaForAllocation() == nullptr && _impl_.table_ != nullptr) { delete _impl_.table_; } _impl_.table_ = nullptr; } inline const ::pg_query::RangeVar& AlterPolicyStmt::_internal_table() const { const ::pg_query::RangeVar* p = _impl_.table_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& AlterPolicyStmt::table() const { // @@protoc_insertion_point(field_get:pg_query.AlterPolicyStmt.table) return _internal_table(); } inline void AlterPolicyStmt::unsafe_arena_set_allocated_table( ::pg_query::RangeVar* table) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.table_); } _impl_.table_ = table; if (table) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterPolicyStmt.table) } inline ::pg_query::RangeVar* AlterPolicyStmt::release_table() { ::pg_query::RangeVar* temp = _impl_.table_; _impl_.table_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* AlterPolicyStmt::unsafe_arena_release_table() { // @@protoc_insertion_point(field_release:pg_query.AlterPolicyStmt.table) ::pg_query::RangeVar* temp = _impl_.table_; _impl_.table_ = nullptr; return temp; } inline ::pg_query::RangeVar* AlterPolicyStmt::_internal_mutable_table() { if (_impl_.table_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.table_ = p; } return _impl_.table_; } inline ::pg_query::RangeVar* AlterPolicyStmt::mutable_table() { ::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* table) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.table_; } if (table) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(table); if (message_arena != submessage_arena) { table = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, table, submessage_arena); } } else { } _impl_.table_ = table; // @@protoc_insertion_point(field_set_allocated:pg_query.AlterPolicyStmt.table) } // repeated .pg_query.Node roles = 3 [json_name = "roles"]; inline int AlterPolicyStmt::_internal_roles_size() const { return _impl_.roles_.size(); } inline int AlterPolicyStmt::roles_size() const { return _internal_roles_size(); } inline void AlterPolicyStmt::clear_roles() { _impl_.roles_.Clear(); } inline ::pg_query::Node* AlterPolicyStmt::mutable_roles(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterPolicyStmt.roles) return _impl_.roles_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterPolicyStmt::mutable_roles() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterPolicyStmt.roles) return &_impl_.roles_; } inline const ::pg_query::Node& AlterPolicyStmt::_internal_roles(int index) const { return _impl_.roles_.Get(index); } inline const ::pg_query::Node& AlterPolicyStmt::roles(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterPolicyStmt.roles) return _internal_roles(index); } inline ::pg_query::Node* AlterPolicyStmt::_internal_add_roles() { return _impl_.roles_.Add(); } inline ::pg_query::Node* AlterPolicyStmt::add_roles() { ::pg_query::Node* _add = _internal_add_roles(); // @@protoc_insertion_point(field_add:pg_query.AlterPolicyStmt.roles) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterPolicyStmt::roles() const { // @@protoc_insertion_point(field_list:pg_query.AlterPolicyStmt.roles) return _impl_.roles_; } // .pg_query.Node qual = 4 [json_name = "qual"]; inline bool AlterPolicyStmt::_internal_has_qual() const { return this != internal_default_instance() && _impl_.qual_ != nullptr; } inline bool AlterPolicyStmt::has_qual() const { return _internal_has_qual(); } inline void AlterPolicyStmt::clear_qual() { if (GetArenaForAllocation() == nullptr && _impl_.qual_ != nullptr) { delete _impl_.qual_; } _impl_.qual_ = nullptr; } inline const ::pg_query::Node& AlterPolicyStmt::_internal_qual() const { const ::pg_query::Node* p = _impl_.qual_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& AlterPolicyStmt::qual() const { // @@protoc_insertion_point(field_get:pg_query.AlterPolicyStmt.qual) return _internal_qual(); } inline void AlterPolicyStmt::unsafe_arena_set_allocated_qual( ::pg_query::Node* qual) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.qual_); } _impl_.qual_ = qual; if (qual) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterPolicyStmt.qual) } inline ::pg_query::Node* AlterPolicyStmt::release_qual() { ::pg_query::Node* temp = _impl_.qual_; _impl_.qual_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* AlterPolicyStmt::unsafe_arena_release_qual() { // @@protoc_insertion_point(field_release:pg_query.AlterPolicyStmt.qual) ::pg_query::Node* temp = _impl_.qual_; _impl_.qual_ = nullptr; return temp; } inline ::pg_query::Node* AlterPolicyStmt::_internal_mutable_qual() { if (_impl_.qual_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.qual_ = p; } return _impl_.qual_; } inline ::pg_query::Node* AlterPolicyStmt::mutable_qual() { ::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* qual) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.qual_; } if (qual) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(qual); if (message_arena != submessage_arena) { qual = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, qual, submessage_arena); } } else { } _impl_.qual_ = qual; // @@protoc_insertion_point(field_set_allocated:pg_query.AlterPolicyStmt.qual) } // .pg_query.Node with_check = 5 [json_name = "with_check"]; inline bool AlterPolicyStmt::_internal_has_with_check() const { return this != internal_default_instance() && _impl_.with_check_ != nullptr; } inline bool AlterPolicyStmt::has_with_check() const { return _internal_has_with_check(); } inline void AlterPolicyStmt::clear_with_check() { if (GetArenaForAllocation() == nullptr && _impl_.with_check_ != nullptr) { delete _impl_.with_check_; } _impl_.with_check_ = nullptr; } inline const ::pg_query::Node& AlterPolicyStmt::_internal_with_check() const { const ::pg_query::Node* p = _impl_.with_check_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& AlterPolicyStmt::with_check() const { // @@protoc_insertion_point(field_get:pg_query.AlterPolicyStmt.with_check) return _internal_with_check(); } inline void AlterPolicyStmt::unsafe_arena_set_allocated_with_check( ::pg_query::Node* with_check) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.with_check_); } _impl_.with_check_ = with_check; if (with_check) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.AlterPolicyStmt.with_check) } inline ::pg_query::Node* AlterPolicyStmt::release_with_check() { ::pg_query::Node* temp = _impl_.with_check_; _impl_.with_check_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* AlterPolicyStmt::unsafe_arena_release_with_check() { // @@protoc_insertion_point(field_release:pg_query.AlterPolicyStmt.with_check) ::pg_query::Node* temp = _impl_.with_check_; _impl_.with_check_ = nullptr; return temp; } inline ::pg_query::Node* AlterPolicyStmt::_internal_mutable_with_check() { if (_impl_.with_check_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.with_check_ = p; } return _impl_.with_check_; } inline ::pg_query::Node* AlterPolicyStmt::mutable_with_check() { ::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* with_check) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.with_check_; } if (with_check) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(with_check); if (message_arena != submessage_arena) { with_check = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, with_check, submessage_arena); } } else { } _impl_.with_check_ = with_check; // @@protoc_insertion_point(field_set_allocated:pg_query.AlterPolicyStmt.with_check) } // ------------------------------------------------------------------- // CreateTransformStmt // bool replace = 1 [json_name = "replace"]; inline void CreateTransformStmt::clear_replace() { _impl_.replace_ = false; } inline bool CreateTransformStmt::_internal_replace() const { return _impl_.replace_; } inline bool CreateTransformStmt::replace() const { // @@protoc_insertion_point(field_get:pg_query.CreateTransformStmt.replace) return _internal_replace(); } inline void CreateTransformStmt::_internal_set_replace(bool value) { _impl_.replace_ = value; } inline void CreateTransformStmt::set_replace(bool value) { _internal_set_replace(value); // @@protoc_insertion_point(field_set:pg_query.CreateTransformStmt.replace) } // .pg_query.TypeName type_name = 2 [json_name = "type_name"]; inline bool CreateTransformStmt::_internal_has_type_name() const { return this != internal_default_instance() && _impl_.type_name_ != nullptr; } inline bool CreateTransformStmt::has_type_name() const { return _internal_has_type_name(); } inline void CreateTransformStmt::clear_type_name() { if (GetArenaForAllocation() == nullptr && _impl_.type_name_ != nullptr) { delete _impl_.type_name_; } _impl_.type_name_ = nullptr; } inline const ::pg_query::TypeName& CreateTransformStmt::_internal_type_name() const { const ::pg_query::TypeName* p = _impl_.type_name_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_TypeName_default_instance_); } inline const ::pg_query::TypeName& CreateTransformStmt::type_name() const { // @@protoc_insertion_point(field_get:pg_query.CreateTransformStmt.type_name) return _internal_type_name(); } inline void CreateTransformStmt::unsafe_arena_set_allocated_type_name( ::pg_query::TypeName* type_name) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.type_name_); } _impl_.type_name_ = type_name; if (type_name) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateTransformStmt.type_name) } inline ::pg_query::TypeName* CreateTransformStmt::release_type_name() { ::pg_query::TypeName* temp = _impl_.type_name_; _impl_.type_name_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::TypeName* CreateTransformStmt::unsafe_arena_release_type_name() { // @@protoc_insertion_point(field_release:pg_query.CreateTransformStmt.type_name) ::pg_query::TypeName* temp = _impl_.type_name_; _impl_.type_name_ = nullptr; return temp; } inline ::pg_query::TypeName* CreateTransformStmt::_internal_mutable_type_name() { if (_impl_.type_name_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArenaForAllocation()); _impl_.type_name_ = p; } return _impl_.type_name_; } inline ::pg_query::TypeName* CreateTransformStmt::mutable_type_name() { ::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* type_name) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.type_name_; } if (type_name) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(type_name); if (message_arena != submessage_arena) { type_name = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, type_name, submessage_arena); } } else { } _impl_.type_name_ = type_name; // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTransformStmt.type_name) } // string lang = 3 [json_name = "lang"]; inline void CreateTransformStmt::clear_lang() { _impl_.lang_.ClearToEmpty(); } inline const std::string& CreateTransformStmt::lang() const { // @@protoc_insertion_point(field_get:pg_query.CreateTransformStmt.lang) return _internal_lang(); } template inline PROTOBUF_ALWAYS_INLINE void CreateTransformStmt::set_lang(ArgT0&& arg0, ArgT... args) { _impl_.lang_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreateTransformStmt.lang) } inline std::string* CreateTransformStmt::mutable_lang() { 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 { return _impl_.lang_.Get(); } inline void CreateTransformStmt::_internal_set_lang(const std::string& value) { _impl_.lang_.Set(value, GetArenaForAllocation()); } inline std::string* CreateTransformStmt::_internal_mutable_lang() { return _impl_.lang_.Mutable(GetArenaForAllocation()); } inline std::string* CreateTransformStmt::release_lang() { // @@protoc_insertion_point(field_release:pg_query.CreateTransformStmt.lang) return _impl_.lang_.Release(); } inline void CreateTransformStmt::set_allocated_lang(std::string* lang) { if (lang != nullptr) { } else { } _impl_.lang_.SetAllocated(lang, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.lang_.IsDefault()) { _impl_.lang_.Set("", GetArenaForAllocation()); } #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::_internal_has_fromsql() const { return this != internal_default_instance() && _impl_.fromsql_ != nullptr; } inline bool CreateTransformStmt::has_fromsql() const { return _internal_has_fromsql(); } inline void CreateTransformStmt::clear_fromsql() { if (GetArenaForAllocation() == nullptr && _impl_.fromsql_ != nullptr) { delete _impl_.fromsql_; } _impl_.fromsql_ = nullptr; } inline const ::pg_query::ObjectWithArgs& CreateTransformStmt::_internal_fromsql() const { const ::pg_query::ObjectWithArgs* p = _impl_.fromsql_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_ObjectWithArgs_default_instance_); } inline const ::pg_query::ObjectWithArgs& CreateTransformStmt::fromsql() const { // @@protoc_insertion_point(field_get:pg_query.CreateTransformStmt.fromsql) return _internal_fromsql(); } inline void CreateTransformStmt::unsafe_arena_set_allocated_fromsql( ::pg_query::ObjectWithArgs* fromsql) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.fromsql_); } _impl_.fromsql_ = fromsql; if (fromsql) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateTransformStmt.fromsql) } inline ::pg_query::ObjectWithArgs* CreateTransformStmt::release_fromsql() { ::pg_query::ObjectWithArgs* temp = _impl_.fromsql_; _impl_.fromsql_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::ObjectWithArgs* CreateTransformStmt::unsafe_arena_release_fromsql() { // @@protoc_insertion_point(field_release:pg_query.CreateTransformStmt.fromsql) ::pg_query::ObjectWithArgs* temp = _impl_.fromsql_; _impl_.fromsql_ = nullptr; return temp; } inline ::pg_query::ObjectWithArgs* CreateTransformStmt::_internal_mutable_fromsql() { if (_impl_.fromsql_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::ObjectWithArgs>(GetArenaForAllocation()); _impl_.fromsql_ = p; } return _impl_.fromsql_; } inline ::pg_query::ObjectWithArgs* CreateTransformStmt::mutable_fromsql() { ::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* fromsql) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.fromsql_; } if (fromsql) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(fromsql); if (message_arena != submessage_arena) { fromsql = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, fromsql, submessage_arena); } } else { } _impl_.fromsql_ = fromsql; // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTransformStmt.fromsql) } // .pg_query.ObjectWithArgs tosql = 5 [json_name = "tosql"]; inline bool CreateTransformStmt::_internal_has_tosql() const { return this != internal_default_instance() && _impl_.tosql_ != nullptr; } inline bool CreateTransformStmt::has_tosql() const { return _internal_has_tosql(); } inline void CreateTransformStmt::clear_tosql() { if (GetArenaForAllocation() == nullptr && _impl_.tosql_ != nullptr) { delete _impl_.tosql_; } _impl_.tosql_ = nullptr; } inline const ::pg_query::ObjectWithArgs& CreateTransformStmt::_internal_tosql() const { const ::pg_query::ObjectWithArgs* p = _impl_.tosql_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_ObjectWithArgs_default_instance_); } inline const ::pg_query::ObjectWithArgs& CreateTransformStmt::tosql() const { // @@protoc_insertion_point(field_get:pg_query.CreateTransformStmt.tosql) return _internal_tosql(); } inline void CreateTransformStmt::unsafe_arena_set_allocated_tosql( ::pg_query::ObjectWithArgs* tosql) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tosql_); } _impl_.tosql_ = tosql; if (tosql) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateTransformStmt.tosql) } inline ::pg_query::ObjectWithArgs* CreateTransformStmt::release_tosql() { ::pg_query::ObjectWithArgs* temp = _impl_.tosql_; _impl_.tosql_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::ObjectWithArgs* CreateTransformStmt::unsafe_arena_release_tosql() { // @@protoc_insertion_point(field_release:pg_query.CreateTransformStmt.tosql) ::pg_query::ObjectWithArgs* temp = _impl_.tosql_; _impl_.tosql_ = nullptr; return temp; } inline ::pg_query::ObjectWithArgs* CreateTransformStmt::_internal_mutable_tosql() { if (_impl_.tosql_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::ObjectWithArgs>(GetArenaForAllocation()); _impl_.tosql_ = p; } return _impl_.tosql_; } inline ::pg_query::ObjectWithArgs* CreateTransformStmt::mutable_tosql() { ::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* tosql) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.tosql_; } if (tosql) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(tosql); if (message_arena != submessage_arena) { tosql = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, tosql, submessage_arena); } } else { } _impl_.tosql_ = tosql; // @@protoc_insertion_point(field_set_allocated:pg_query.CreateTransformStmt.tosql) } // ------------------------------------------------------------------- // CreateAmStmt // string amname = 1 [json_name = "amname"]; inline void CreateAmStmt::clear_amname() { _impl_.amname_.ClearToEmpty(); } inline const std::string& CreateAmStmt::amname() const { // @@protoc_insertion_point(field_get:pg_query.CreateAmStmt.amname) return _internal_amname(); } template inline PROTOBUF_ALWAYS_INLINE void CreateAmStmt::set_amname(ArgT0&& arg0, ArgT... args) { _impl_.amname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreateAmStmt.amname) } inline std::string* CreateAmStmt::mutable_amname() { 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 { return _impl_.amname_.Get(); } inline void CreateAmStmt::_internal_set_amname(const std::string& value) { _impl_.amname_.Set(value, GetArenaForAllocation()); } inline std::string* CreateAmStmt::_internal_mutable_amname() { return _impl_.amname_.Mutable(GetArenaForAllocation()); } inline std::string* CreateAmStmt::release_amname() { // @@protoc_insertion_point(field_release:pg_query.CreateAmStmt.amname) return _impl_.amname_.Release(); } inline void CreateAmStmt::set_allocated_amname(std::string* amname) { if (amname != nullptr) { } else { } _impl_.amname_.SetAllocated(amname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.amname_.IsDefault()) { _impl_.amname_.Set("", GetArenaForAllocation()); } #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 _impl_.handler_name_.size(); } inline int CreateAmStmt::handler_name_size() const { return _internal_handler_name_size(); } inline void CreateAmStmt::clear_handler_name() { _impl_.handler_name_.Clear(); } inline ::pg_query::Node* CreateAmStmt::mutable_handler_name(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateAmStmt.handler_name) return _impl_.handler_name_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateAmStmt::mutable_handler_name() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateAmStmt.handler_name) return &_impl_.handler_name_; } inline const ::pg_query::Node& CreateAmStmt::_internal_handler_name(int index) const { return _impl_.handler_name_.Get(index); } inline const ::pg_query::Node& CreateAmStmt::handler_name(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateAmStmt.handler_name) return _internal_handler_name(index); } inline ::pg_query::Node* CreateAmStmt::_internal_add_handler_name() { return _impl_.handler_name_.Add(); } inline ::pg_query::Node* CreateAmStmt::add_handler_name() { ::pg_query::Node* _add = _internal_add_handler_name(); // @@protoc_insertion_point(field_add:pg_query.CreateAmStmt.handler_name) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateAmStmt::handler_name() const { // @@protoc_insertion_point(field_list:pg_query.CreateAmStmt.handler_name) return _impl_.handler_name_; } // string amtype = 3 [json_name = "amtype"]; inline void CreateAmStmt::clear_amtype() { _impl_.amtype_.ClearToEmpty(); } inline const std::string& CreateAmStmt::amtype() const { // @@protoc_insertion_point(field_get:pg_query.CreateAmStmt.amtype) return _internal_amtype(); } template inline PROTOBUF_ALWAYS_INLINE void CreateAmStmt::set_amtype(ArgT0&& arg0, ArgT... args) { _impl_.amtype_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreateAmStmt.amtype) } inline std::string* CreateAmStmt::mutable_amtype() { 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 { return _impl_.amtype_.Get(); } inline void CreateAmStmt::_internal_set_amtype(const std::string& value) { _impl_.amtype_.Set(value, GetArenaForAllocation()); } inline std::string* CreateAmStmt::_internal_mutable_amtype() { return _impl_.amtype_.Mutable(GetArenaForAllocation()); } inline std::string* CreateAmStmt::release_amtype() { // @@protoc_insertion_point(field_release:pg_query.CreateAmStmt.amtype) return _impl_.amtype_.Release(); } inline void CreateAmStmt::set_allocated_amtype(std::string* amtype) { if (amtype != nullptr) { } else { } _impl_.amtype_.SetAllocated(amtype, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.amtype_.IsDefault()) { _impl_.amtype_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:pg_query.CreateAmStmt.amtype) } // ------------------------------------------------------------------- // CreatePublicationStmt // string pubname = 1 [json_name = "pubname"]; inline void CreatePublicationStmt::clear_pubname() { _impl_.pubname_.ClearToEmpty(); } inline const std::string& CreatePublicationStmt::pubname() const { // @@protoc_insertion_point(field_get:pg_query.CreatePublicationStmt.pubname) return _internal_pubname(); } template inline PROTOBUF_ALWAYS_INLINE void CreatePublicationStmt::set_pubname(ArgT0&& arg0, ArgT... args) { _impl_.pubname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreatePublicationStmt.pubname) } inline std::string* CreatePublicationStmt::mutable_pubname() { 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 { return _impl_.pubname_.Get(); } inline void CreatePublicationStmt::_internal_set_pubname(const std::string& value) { _impl_.pubname_.Set(value, GetArenaForAllocation()); } inline std::string* CreatePublicationStmt::_internal_mutable_pubname() { return _impl_.pubname_.Mutable(GetArenaForAllocation()); } inline std::string* CreatePublicationStmt::release_pubname() { // @@protoc_insertion_point(field_release:pg_query.CreatePublicationStmt.pubname) return _impl_.pubname_.Release(); } inline void CreatePublicationStmt::set_allocated_pubname(std::string* pubname) { if (pubname != nullptr) { } else { } _impl_.pubname_.SetAllocated(pubname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.pubname_.IsDefault()) { _impl_.pubname_.Set("", GetArenaForAllocation()); } #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 _impl_.options_.size(); } inline int CreatePublicationStmt::options_size() const { return _internal_options_size(); } inline void CreatePublicationStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* CreatePublicationStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreatePublicationStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreatePublicationStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreatePublicationStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& CreatePublicationStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& CreatePublicationStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreatePublicationStmt.options) return _internal_options(index); } inline ::pg_query::Node* CreatePublicationStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* CreatePublicationStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.CreatePublicationStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreatePublicationStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.CreatePublicationStmt.options) return _impl_.options_; } // repeated .pg_query.Node pubobjects = 3 [json_name = "pubobjects"]; inline int CreatePublicationStmt::_internal_pubobjects_size() const { return _impl_.pubobjects_.size(); } inline int CreatePublicationStmt::pubobjects_size() const { return _internal_pubobjects_size(); } inline void CreatePublicationStmt::clear_pubobjects() { _impl_.pubobjects_.Clear(); } inline ::pg_query::Node* CreatePublicationStmt::mutable_pubobjects(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreatePublicationStmt.pubobjects) return _impl_.pubobjects_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreatePublicationStmt::mutable_pubobjects() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreatePublicationStmt.pubobjects) return &_impl_.pubobjects_; } inline const ::pg_query::Node& CreatePublicationStmt::_internal_pubobjects(int index) const { return _impl_.pubobjects_.Get(index); } inline const ::pg_query::Node& CreatePublicationStmt::pubobjects(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreatePublicationStmt.pubobjects) return _internal_pubobjects(index); } inline ::pg_query::Node* CreatePublicationStmt::_internal_add_pubobjects() { return _impl_.pubobjects_.Add(); } inline ::pg_query::Node* CreatePublicationStmt::add_pubobjects() { ::pg_query::Node* _add = _internal_add_pubobjects(); // @@protoc_insertion_point(field_add:pg_query.CreatePublicationStmt.pubobjects) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreatePublicationStmt::pubobjects() const { // @@protoc_insertion_point(field_list:pg_query.CreatePublicationStmt.pubobjects) return _impl_.pubobjects_; } // bool for_all_tables = 4 [json_name = "for_all_tables"]; inline void CreatePublicationStmt::clear_for_all_tables() { _impl_.for_all_tables_ = false; } inline bool CreatePublicationStmt::_internal_for_all_tables() const { return _impl_.for_all_tables_; } inline bool CreatePublicationStmt::for_all_tables() const { // @@protoc_insertion_point(field_get:pg_query.CreatePublicationStmt.for_all_tables) return _internal_for_all_tables(); } inline void CreatePublicationStmt::_internal_set_for_all_tables(bool value) { _impl_.for_all_tables_ = value; } inline void CreatePublicationStmt::set_for_all_tables(bool value) { _internal_set_for_all_tables(value); // @@protoc_insertion_point(field_set:pg_query.CreatePublicationStmt.for_all_tables) } // ------------------------------------------------------------------- // AlterPublicationStmt // string pubname = 1 [json_name = "pubname"]; inline void AlterPublicationStmt::clear_pubname() { _impl_.pubname_.ClearToEmpty(); } inline const std::string& AlterPublicationStmt::pubname() const { // @@protoc_insertion_point(field_get:pg_query.AlterPublicationStmt.pubname) return _internal_pubname(); } template inline PROTOBUF_ALWAYS_INLINE void AlterPublicationStmt::set_pubname(ArgT0&& arg0, ArgT... args) { _impl_.pubname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.AlterPublicationStmt.pubname) } inline std::string* AlterPublicationStmt::mutable_pubname() { 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 { return _impl_.pubname_.Get(); } inline void AlterPublicationStmt::_internal_set_pubname(const std::string& value) { _impl_.pubname_.Set(value, GetArenaForAllocation()); } inline std::string* AlterPublicationStmt::_internal_mutable_pubname() { return _impl_.pubname_.Mutable(GetArenaForAllocation()); } inline std::string* AlterPublicationStmt::release_pubname() { // @@protoc_insertion_point(field_release:pg_query.AlterPublicationStmt.pubname) return _impl_.pubname_.Release(); } inline void AlterPublicationStmt::set_allocated_pubname(std::string* pubname) { if (pubname != nullptr) { } else { } _impl_.pubname_.SetAllocated(pubname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.pubname_.IsDefault()) { _impl_.pubname_.Set("", GetArenaForAllocation()); } #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 _impl_.options_.size(); } inline int AlterPublicationStmt::options_size() const { return _internal_options_size(); } inline void AlterPublicationStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* AlterPublicationStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterPublicationStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterPublicationStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterPublicationStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& AlterPublicationStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& AlterPublicationStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterPublicationStmt.options) return _internal_options(index); } inline ::pg_query::Node* AlterPublicationStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* AlterPublicationStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.AlterPublicationStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterPublicationStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.AlterPublicationStmt.options) return _impl_.options_; } // repeated .pg_query.Node pubobjects = 3 [json_name = "pubobjects"]; inline int AlterPublicationStmt::_internal_pubobjects_size() const { return _impl_.pubobjects_.size(); } inline int AlterPublicationStmt::pubobjects_size() const { return _internal_pubobjects_size(); } inline void AlterPublicationStmt::clear_pubobjects() { _impl_.pubobjects_.Clear(); } inline ::pg_query::Node* AlterPublicationStmt::mutable_pubobjects(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterPublicationStmt.pubobjects) return _impl_.pubobjects_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterPublicationStmt::mutable_pubobjects() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterPublicationStmt.pubobjects) return &_impl_.pubobjects_; } inline const ::pg_query::Node& AlterPublicationStmt::_internal_pubobjects(int index) const { return _impl_.pubobjects_.Get(index); } inline const ::pg_query::Node& AlterPublicationStmt::pubobjects(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterPublicationStmt.pubobjects) return _internal_pubobjects(index); } inline ::pg_query::Node* AlterPublicationStmt::_internal_add_pubobjects() { return _impl_.pubobjects_.Add(); } inline ::pg_query::Node* AlterPublicationStmt::add_pubobjects() { ::pg_query::Node* _add = _internal_add_pubobjects(); // @@protoc_insertion_point(field_add:pg_query.AlterPublicationStmt.pubobjects) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterPublicationStmt::pubobjects() const { // @@protoc_insertion_point(field_list:pg_query.AlterPublicationStmt.pubobjects) return _impl_.pubobjects_; } // bool for_all_tables = 4 [json_name = "for_all_tables"]; inline void AlterPublicationStmt::clear_for_all_tables() { _impl_.for_all_tables_ = false; } inline bool AlterPublicationStmt::_internal_for_all_tables() const { return _impl_.for_all_tables_; } inline bool AlterPublicationStmt::for_all_tables() const { // @@protoc_insertion_point(field_get:pg_query.AlterPublicationStmt.for_all_tables) return _internal_for_all_tables(); } inline void AlterPublicationStmt::_internal_set_for_all_tables(bool value) { _impl_.for_all_tables_ = value; } inline void AlterPublicationStmt::set_for_all_tables(bool value) { _internal_set_for_all_tables(value); // @@protoc_insertion_point(field_set:pg_query.AlterPublicationStmt.for_all_tables) } // .pg_query.AlterPublicationAction action = 5 [json_name = "action"]; inline void AlterPublicationStmt::clear_action() { _impl_.action_ = 0; } inline ::pg_query::AlterPublicationAction AlterPublicationStmt::_internal_action() const { return static_cast< ::pg_query::AlterPublicationAction >(_impl_.action_); } inline ::pg_query::AlterPublicationAction AlterPublicationStmt::action() const { // @@protoc_insertion_point(field_get:pg_query.AlterPublicationStmt.action) return _internal_action(); } inline void AlterPublicationStmt::_internal_set_action(::pg_query::AlterPublicationAction value) { _impl_.action_ = value; } inline void AlterPublicationStmt::set_action(::pg_query::AlterPublicationAction value) { _internal_set_action(value); // @@protoc_insertion_point(field_set:pg_query.AlterPublicationStmt.action) } // ------------------------------------------------------------------- // CreateSubscriptionStmt // string subname = 1 [json_name = "subname"]; inline void CreateSubscriptionStmt::clear_subname() { _impl_.subname_.ClearToEmpty(); } inline const std::string& CreateSubscriptionStmt::subname() const { // @@protoc_insertion_point(field_get:pg_query.CreateSubscriptionStmt.subname) return _internal_subname(); } template inline PROTOBUF_ALWAYS_INLINE void CreateSubscriptionStmt::set_subname(ArgT0&& arg0, ArgT... args) { _impl_.subname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreateSubscriptionStmt.subname) } inline std::string* CreateSubscriptionStmt::mutable_subname() { 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 { return _impl_.subname_.Get(); } inline void CreateSubscriptionStmt::_internal_set_subname(const std::string& value) { _impl_.subname_.Set(value, GetArenaForAllocation()); } inline std::string* CreateSubscriptionStmt::_internal_mutable_subname() { return _impl_.subname_.Mutable(GetArenaForAllocation()); } inline std::string* CreateSubscriptionStmt::release_subname() { // @@protoc_insertion_point(field_release:pg_query.CreateSubscriptionStmt.subname) return _impl_.subname_.Release(); } inline void CreateSubscriptionStmt::set_allocated_subname(std::string* subname) { if (subname != nullptr) { } else { } _impl_.subname_.SetAllocated(subname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.subname_.IsDefault()) { _impl_.subname_.Set("", GetArenaForAllocation()); } #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() { _impl_.conninfo_.ClearToEmpty(); } inline const std::string& CreateSubscriptionStmt::conninfo() const { // @@protoc_insertion_point(field_get:pg_query.CreateSubscriptionStmt.conninfo) return _internal_conninfo(); } template inline PROTOBUF_ALWAYS_INLINE void CreateSubscriptionStmt::set_conninfo(ArgT0&& arg0, ArgT... args) { _impl_.conninfo_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreateSubscriptionStmt.conninfo) } inline std::string* CreateSubscriptionStmt::mutable_conninfo() { 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 { return _impl_.conninfo_.Get(); } inline void CreateSubscriptionStmt::_internal_set_conninfo(const std::string& value) { _impl_.conninfo_.Set(value, GetArenaForAllocation()); } inline std::string* CreateSubscriptionStmt::_internal_mutable_conninfo() { return _impl_.conninfo_.Mutable(GetArenaForAllocation()); } inline std::string* CreateSubscriptionStmt::release_conninfo() { // @@protoc_insertion_point(field_release:pg_query.CreateSubscriptionStmt.conninfo) return _impl_.conninfo_.Release(); } inline void CreateSubscriptionStmt::set_allocated_conninfo(std::string* conninfo) { if (conninfo != nullptr) { } else { } _impl_.conninfo_.SetAllocated(conninfo, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.conninfo_.IsDefault()) { _impl_.conninfo_.Set("", GetArenaForAllocation()); } #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 _impl_.publication_.size(); } inline int CreateSubscriptionStmt::publication_size() const { return _internal_publication_size(); } inline void CreateSubscriptionStmt::clear_publication() { _impl_.publication_.Clear(); } inline ::pg_query::Node* CreateSubscriptionStmt::mutable_publication(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateSubscriptionStmt.publication) return _impl_.publication_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateSubscriptionStmt::mutable_publication() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateSubscriptionStmt.publication) return &_impl_.publication_; } inline const ::pg_query::Node& CreateSubscriptionStmt::_internal_publication(int index) const { return _impl_.publication_.Get(index); } inline const ::pg_query::Node& CreateSubscriptionStmt::publication(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateSubscriptionStmt.publication) return _internal_publication(index); } inline ::pg_query::Node* CreateSubscriptionStmt::_internal_add_publication() { return _impl_.publication_.Add(); } inline ::pg_query::Node* CreateSubscriptionStmt::add_publication() { ::pg_query::Node* _add = _internal_add_publication(); // @@protoc_insertion_point(field_add:pg_query.CreateSubscriptionStmt.publication) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateSubscriptionStmt::publication() const { // @@protoc_insertion_point(field_list:pg_query.CreateSubscriptionStmt.publication) return _impl_.publication_; } // repeated .pg_query.Node options = 4 [json_name = "options"]; inline int CreateSubscriptionStmt::_internal_options_size() const { return _impl_.options_.size(); } inline int CreateSubscriptionStmt::options_size() const { return _internal_options_size(); } inline void CreateSubscriptionStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* CreateSubscriptionStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateSubscriptionStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateSubscriptionStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateSubscriptionStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& CreateSubscriptionStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& CreateSubscriptionStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateSubscriptionStmt.options) return _internal_options(index); } inline ::pg_query::Node* CreateSubscriptionStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* CreateSubscriptionStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.CreateSubscriptionStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateSubscriptionStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.CreateSubscriptionStmt.options) return _impl_.options_; } // ------------------------------------------------------------------- // AlterSubscriptionStmt // .pg_query.AlterSubscriptionType kind = 1 [json_name = "kind"]; inline void AlterSubscriptionStmt::clear_kind() { _impl_.kind_ = 0; } inline ::pg_query::AlterSubscriptionType AlterSubscriptionStmt::_internal_kind() const { return static_cast< ::pg_query::AlterSubscriptionType >(_impl_.kind_); } inline ::pg_query::AlterSubscriptionType AlterSubscriptionStmt::kind() const { // @@protoc_insertion_point(field_get:pg_query.AlterSubscriptionStmt.kind) return _internal_kind(); } inline void AlterSubscriptionStmt::_internal_set_kind(::pg_query::AlterSubscriptionType value) { _impl_.kind_ = value; } inline void AlterSubscriptionStmt::set_kind(::pg_query::AlterSubscriptionType value) { _internal_set_kind(value); // @@protoc_insertion_point(field_set:pg_query.AlterSubscriptionStmt.kind) } // string subname = 2 [json_name = "subname"]; inline void AlterSubscriptionStmt::clear_subname() { _impl_.subname_.ClearToEmpty(); } inline const std::string& AlterSubscriptionStmt::subname() const { // @@protoc_insertion_point(field_get:pg_query.AlterSubscriptionStmt.subname) return _internal_subname(); } template inline PROTOBUF_ALWAYS_INLINE void AlterSubscriptionStmt::set_subname(ArgT0&& arg0, ArgT... args) { _impl_.subname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.AlterSubscriptionStmt.subname) } inline std::string* AlterSubscriptionStmt::mutable_subname() { 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 { return _impl_.subname_.Get(); } inline void AlterSubscriptionStmt::_internal_set_subname(const std::string& value) { _impl_.subname_.Set(value, GetArenaForAllocation()); } inline std::string* AlterSubscriptionStmt::_internal_mutable_subname() { return _impl_.subname_.Mutable(GetArenaForAllocation()); } inline std::string* AlterSubscriptionStmt::release_subname() { // @@protoc_insertion_point(field_release:pg_query.AlterSubscriptionStmt.subname) return _impl_.subname_.Release(); } inline void AlterSubscriptionStmt::set_allocated_subname(std::string* subname) { if (subname != nullptr) { } else { } _impl_.subname_.SetAllocated(subname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.subname_.IsDefault()) { _impl_.subname_.Set("", GetArenaForAllocation()); } #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() { _impl_.conninfo_.ClearToEmpty(); } inline const std::string& AlterSubscriptionStmt::conninfo() const { // @@protoc_insertion_point(field_get:pg_query.AlterSubscriptionStmt.conninfo) return _internal_conninfo(); } template inline PROTOBUF_ALWAYS_INLINE void AlterSubscriptionStmt::set_conninfo(ArgT0&& arg0, ArgT... args) { _impl_.conninfo_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.AlterSubscriptionStmt.conninfo) } inline std::string* AlterSubscriptionStmt::mutable_conninfo() { 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 { return _impl_.conninfo_.Get(); } inline void AlterSubscriptionStmt::_internal_set_conninfo(const std::string& value) { _impl_.conninfo_.Set(value, GetArenaForAllocation()); } inline std::string* AlterSubscriptionStmt::_internal_mutable_conninfo() { return _impl_.conninfo_.Mutable(GetArenaForAllocation()); } inline std::string* AlterSubscriptionStmt::release_conninfo() { // @@protoc_insertion_point(field_release:pg_query.AlterSubscriptionStmt.conninfo) return _impl_.conninfo_.Release(); } inline void AlterSubscriptionStmt::set_allocated_conninfo(std::string* conninfo) { if (conninfo != nullptr) { } else { } _impl_.conninfo_.SetAllocated(conninfo, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.conninfo_.IsDefault()) { _impl_.conninfo_.Set("", GetArenaForAllocation()); } #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 _impl_.publication_.size(); } inline int AlterSubscriptionStmt::publication_size() const { return _internal_publication_size(); } inline void AlterSubscriptionStmt::clear_publication() { _impl_.publication_.Clear(); } inline ::pg_query::Node* AlterSubscriptionStmt::mutable_publication(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterSubscriptionStmt.publication) return _impl_.publication_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterSubscriptionStmt::mutable_publication() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterSubscriptionStmt.publication) return &_impl_.publication_; } inline const ::pg_query::Node& AlterSubscriptionStmt::_internal_publication(int index) const { return _impl_.publication_.Get(index); } inline const ::pg_query::Node& AlterSubscriptionStmt::publication(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterSubscriptionStmt.publication) return _internal_publication(index); } inline ::pg_query::Node* AlterSubscriptionStmt::_internal_add_publication() { return _impl_.publication_.Add(); } inline ::pg_query::Node* AlterSubscriptionStmt::add_publication() { ::pg_query::Node* _add = _internal_add_publication(); // @@protoc_insertion_point(field_add:pg_query.AlterSubscriptionStmt.publication) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterSubscriptionStmt::publication() const { // @@protoc_insertion_point(field_list:pg_query.AlterSubscriptionStmt.publication) return _impl_.publication_; } // repeated .pg_query.Node options = 5 [json_name = "options"]; inline int AlterSubscriptionStmt::_internal_options_size() const { return _impl_.options_.size(); } inline int AlterSubscriptionStmt::options_size() const { return _internal_options_size(); } inline void AlterSubscriptionStmt::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* AlterSubscriptionStmt::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterSubscriptionStmt.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterSubscriptionStmt::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterSubscriptionStmt.options) return &_impl_.options_; } inline const ::pg_query::Node& AlterSubscriptionStmt::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& AlterSubscriptionStmt::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterSubscriptionStmt.options) return _internal_options(index); } inline ::pg_query::Node* AlterSubscriptionStmt::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* AlterSubscriptionStmt::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.AlterSubscriptionStmt.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterSubscriptionStmt::options() const { // @@protoc_insertion_point(field_list:pg_query.AlterSubscriptionStmt.options) return _impl_.options_; } // ------------------------------------------------------------------- // DropSubscriptionStmt // string subname = 1 [json_name = "subname"]; inline void DropSubscriptionStmt::clear_subname() { _impl_.subname_.ClearToEmpty(); } inline const std::string& DropSubscriptionStmt::subname() const { // @@protoc_insertion_point(field_get:pg_query.DropSubscriptionStmt.subname) return _internal_subname(); } template inline PROTOBUF_ALWAYS_INLINE void DropSubscriptionStmt::set_subname(ArgT0&& arg0, ArgT... args) { _impl_.subname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.DropSubscriptionStmt.subname) } inline std::string* DropSubscriptionStmt::mutable_subname() { 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 { return _impl_.subname_.Get(); } inline void DropSubscriptionStmt::_internal_set_subname(const std::string& value) { _impl_.subname_.Set(value, GetArenaForAllocation()); } inline std::string* DropSubscriptionStmt::_internal_mutable_subname() { return _impl_.subname_.Mutable(GetArenaForAllocation()); } inline std::string* DropSubscriptionStmt::release_subname() { // @@protoc_insertion_point(field_release:pg_query.DropSubscriptionStmt.subname) return _impl_.subname_.Release(); } inline void DropSubscriptionStmt::set_allocated_subname(std::string* subname) { if (subname != nullptr) { } else { } _impl_.subname_.SetAllocated(subname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.subname_.IsDefault()) { _impl_.subname_.Set("", GetArenaForAllocation()); } #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() { _impl_.missing_ok_ = false; } inline bool DropSubscriptionStmt::_internal_missing_ok() const { return _impl_.missing_ok_; } inline bool DropSubscriptionStmt::missing_ok() const { // @@protoc_insertion_point(field_get:pg_query.DropSubscriptionStmt.missing_ok) return _internal_missing_ok(); } inline void DropSubscriptionStmt::_internal_set_missing_ok(bool value) { _impl_.missing_ok_ = value; } inline void DropSubscriptionStmt::set_missing_ok(bool value) { _internal_set_missing_ok(value); // @@protoc_insertion_point(field_set:pg_query.DropSubscriptionStmt.missing_ok) } // .pg_query.DropBehavior behavior = 3 [json_name = "behavior"]; inline void DropSubscriptionStmt::clear_behavior() { _impl_.behavior_ = 0; } inline ::pg_query::DropBehavior DropSubscriptionStmt::_internal_behavior() const { return static_cast< ::pg_query::DropBehavior >(_impl_.behavior_); } inline ::pg_query::DropBehavior DropSubscriptionStmt::behavior() const { // @@protoc_insertion_point(field_get:pg_query.DropSubscriptionStmt.behavior) return _internal_behavior(); } inline void DropSubscriptionStmt::_internal_set_behavior(::pg_query::DropBehavior value) { _impl_.behavior_ = value; } inline void DropSubscriptionStmt::set_behavior(::pg_query::DropBehavior value) { _internal_set_behavior(value); // @@protoc_insertion_point(field_set:pg_query.DropSubscriptionStmt.behavior) } // ------------------------------------------------------------------- // CreateStatsStmt // repeated .pg_query.Node defnames = 1 [json_name = "defnames"]; inline int CreateStatsStmt::_internal_defnames_size() const { return _impl_.defnames_.size(); } inline int CreateStatsStmt::defnames_size() const { return _internal_defnames_size(); } inline void CreateStatsStmt::clear_defnames() { _impl_.defnames_.Clear(); } inline ::pg_query::Node* CreateStatsStmt::mutable_defnames(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateStatsStmt.defnames) return _impl_.defnames_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateStatsStmt::mutable_defnames() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateStatsStmt.defnames) return &_impl_.defnames_; } inline const ::pg_query::Node& CreateStatsStmt::_internal_defnames(int index) const { return _impl_.defnames_.Get(index); } inline const ::pg_query::Node& CreateStatsStmt::defnames(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateStatsStmt.defnames) return _internal_defnames(index); } inline ::pg_query::Node* CreateStatsStmt::_internal_add_defnames() { return _impl_.defnames_.Add(); } inline ::pg_query::Node* CreateStatsStmt::add_defnames() { ::pg_query::Node* _add = _internal_add_defnames(); // @@protoc_insertion_point(field_add:pg_query.CreateStatsStmt.defnames) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateStatsStmt::defnames() const { // @@protoc_insertion_point(field_list:pg_query.CreateStatsStmt.defnames) return _impl_.defnames_; } // repeated .pg_query.Node stat_types = 2 [json_name = "stat_types"]; inline int CreateStatsStmt::_internal_stat_types_size() const { return _impl_.stat_types_.size(); } inline int CreateStatsStmt::stat_types_size() const { return _internal_stat_types_size(); } inline void CreateStatsStmt::clear_stat_types() { _impl_.stat_types_.Clear(); } inline ::pg_query::Node* CreateStatsStmt::mutable_stat_types(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateStatsStmt.stat_types) return _impl_.stat_types_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateStatsStmt::mutable_stat_types() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateStatsStmt.stat_types) return &_impl_.stat_types_; } inline const ::pg_query::Node& CreateStatsStmt::_internal_stat_types(int index) const { return _impl_.stat_types_.Get(index); } inline const ::pg_query::Node& CreateStatsStmt::stat_types(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateStatsStmt.stat_types) return _internal_stat_types(index); } inline ::pg_query::Node* CreateStatsStmt::_internal_add_stat_types() { return _impl_.stat_types_.Add(); } inline ::pg_query::Node* CreateStatsStmt::add_stat_types() { ::pg_query::Node* _add = _internal_add_stat_types(); // @@protoc_insertion_point(field_add:pg_query.CreateStatsStmt.stat_types) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateStatsStmt::stat_types() const { // @@protoc_insertion_point(field_list:pg_query.CreateStatsStmt.stat_types) return _impl_.stat_types_; } // repeated .pg_query.Node exprs = 3 [json_name = "exprs"]; inline int CreateStatsStmt::_internal_exprs_size() const { return _impl_.exprs_.size(); } inline int CreateStatsStmt::exprs_size() const { return _internal_exprs_size(); } inline void CreateStatsStmt::clear_exprs() { _impl_.exprs_.Clear(); } inline ::pg_query::Node* CreateStatsStmt::mutable_exprs(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateStatsStmt.exprs) return _impl_.exprs_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateStatsStmt::mutable_exprs() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateStatsStmt.exprs) return &_impl_.exprs_; } inline const ::pg_query::Node& CreateStatsStmt::_internal_exprs(int index) const { return _impl_.exprs_.Get(index); } inline const ::pg_query::Node& CreateStatsStmt::exprs(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateStatsStmt.exprs) return _internal_exprs(index); } inline ::pg_query::Node* CreateStatsStmt::_internal_add_exprs() { return _impl_.exprs_.Add(); } inline ::pg_query::Node* CreateStatsStmt::add_exprs() { ::pg_query::Node* _add = _internal_add_exprs(); // @@protoc_insertion_point(field_add:pg_query.CreateStatsStmt.exprs) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateStatsStmt::exprs() const { // @@protoc_insertion_point(field_list:pg_query.CreateStatsStmt.exprs) return _impl_.exprs_; } // repeated .pg_query.Node relations = 4 [json_name = "relations"]; inline int CreateStatsStmt::_internal_relations_size() const { return _impl_.relations_.size(); } inline int CreateStatsStmt::relations_size() const { return _internal_relations_size(); } inline void CreateStatsStmt::clear_relations() { _impl_.relations_.Clear(); } inline ::pg_query::Node* CreateStatsStmt::mutable_relations(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateStatsStmt.relations) return _impl_.relations_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateStatsStmt::mutable_relations() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateStatsStmt.relations) return &_impl_.relations_; } inline const ::pg_query::Node& CreateStatsStmt::_internal_relations(int index) const { return _impl_.relations_.Get(index); } inline const ::pg_query::Node& CreateStatsStmt::relations(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateStatsStmt.relations) return _internal_relations(index); } inline ::pg_query::Node* CreateStatsStmt::_internal_add_relations() { return _impl_.relations_.Add(); } inline ::pg_query::Node* CreateStatsStmt::add_relations() { ::pg_query::Node* _add = _internal_add_relations(); // @@protoc_insertion_point(field_add:pg_query.CreateStatsStmt.relations) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateStatsStmt::relations() const { // @@protoc_insertion_point(field_list:pg_query.CreateStatsStmt.relations) return _impl_.relations_; } // string stxcomment = 5 [json_name = "stxcomment"]; inline void CreateStatsStmt::clear_stxcomment() { _impl_.stxcomment_.ClearToEmpty(); } inline const std::string& CreateStatsStmt::stxcomment() const { // @@protoc_insertion_point(field_get:pg_query.CreateStatsStmt.stxcomment) return _internal_stxcomment(); } template inline PROTOBUF_ALWAYS_INLINE void CreateStatsStmt::set_stxcomment(ArgT0&& arg0, ArgT... args) { _impl_.stxcomment_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CreateStatsStmt.stxcomment) } inline std::string* CreateStatsStmt::mutable_stxcomment() { 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 { return _impl_.stxcomment_.Get(); } inline void CreateStatsStmt::_internal_set_stxcomment(const std::string& value) { _impl_.stxcomment_.Set(value, GetArenaForAllocation()); } inline std::string* CreateStatsStmt::_internal_mutable_stxcomment() { return _impl_.stxcomment_.Mutable(GetArenaForAllocation()); } inline std::string* CreateStatsStmt::release_stxcomment() { // @@protoc_insertion_point(field_release:pg_query.CreateStatsStmt.stxcomment) return _impl_.stxcomment_.Release(); } inline void CreateStatsStmt::set_allocated_stxcomment(std::string* stxcomment) { if (stxcomment != nullptr) { } else { } _impl_.stxcomment_.SetAllocated(stxcomment, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.stxcomment_.IsDefault()) { _impl_.stxcomment_.Set("", GetArenaForAllocation()); } #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() { _impl_.transformed_ = false; } inline bool CreateStatsStmt::_internal_transformed() const { return _impl_.transformed_; } inline bool CreateStatsStmt::transformed() const { // @@protoc_insertion_point(field_get:pg_query.CreateStatsStmt.transformed) return _internal_transformed(); } inline void CreateStatsStmt::_internal_set_transformed(bool value) { _impl_.transformed_ = value; } inline void CreateStatsStmt::set_transformed(bool value) { _internal_set_transformed(value); // @@protoc_insertion_point(field_set:pg_query.CreateStatsStmt.transformed) } // bool if_not_exists = 7 [json_name = "if_not_exists"]; inline void CreateStatsStmt::clear_if_not_exists() { _impl_.if_not_exists_ = false; } inline bool CreateStatsStmt::_internal_if_not_exists() const { return _impl_.if_not_exists_; } inline bool CreateStatsStmt::if_not_exists() const { // @@protoc_insertion_point(field_get:pg_query.CreateStatsStmt.if_not_exists) return _internal_if_not_exists(); } inline void CreateStatsStmt::_internal_set_if_not_exists(bool value) { _impl_.if_not_exists_ = value; } inline void CreateStatsStmt::set_if_not_exists(bool value) { _internal_set_if_not_exists(value); // @@protoc_insertion_point(field_set:pg_query.CreateStatsStmt.if_not_exists) } // ------------------------------------------------------------------- // AlterCollationStmt // repeated .pg_query.Node collname = 1 [json_name = "collname"]; inline int AlterCollationStmt::_internal_collname_size() const { return _impl_.collname_.size(); } inline int AlterCollationStmt::collname_size() const { return _internal_collname_size(); } inline void AlterCollationStmt::clear_collname() { _impl_.collname_.Clear(); } inline ::pg_query::Node* AlterCollationStmt::mutable_collname(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterCollationStmt.collname) return _impl_.collname_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterCollationStmt::mutable_collname() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterCollationStmt.collname) return &_impl_.collname_; } inline const ::pg_query::Node& AlterCollationStmt::_internal_collname(int index) const { return _impl_.collname_.Get(index); } inline const ::pg_query::Node& AlterCollationStmt::collname(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterCollationStmt.collname) return _internal_collname(index); } inline ::pg_query::Node* AlterCollationStmt::_internal_add_collname() { return _impl_.collname_.Add(); } inline ::pg_query::Node* AlterCollationStmt::add_collname() { ::pg_query::Node* _add = _internal_add_collname(); // @@protoc_insertion_point(field_add:pg_query.AlterCollationStmt.collname) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterCollationStmt::collname() const { // @@protoc_insertion_point(field_list:pg_query.AlterCollationStmt.collname) return _impl_.collname_; } // ------------------------------------------------------------------- // CallStmt // .pg_query.FuncCall funccall = 1 [json_name = "funccall"]; inline bool CallStmt::_internal_has_funccall() const { return this != internal_default_instance() && _impl_.funccall_ != nullptr; } inline bool CallStmt::has_funccall() const { return _internal_has_funccall(); } inline void CallStmt::clear_funccall() { if (GetArenaForAllocation() == nullptr && _impl_.funccall_ != nullptr) { delete _impl_.funccall_; } _impl_.funccall_ = nullptr; } inline const ::pg_query::FuncCall& CallStmt::_internal_funccall() const { const ::pg_query::FuncCall* p = _impl_.funccall_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_FuncCall_default_instance_); } inline const ::pg_query::FuncCall& CallStmt::funccall() const { // @@protoc_insertion_point(field_get:pg_query.CallStmt.funccall) return _internal_funccall(); } inline void CallStmt::unsafe_arena_set_allocated_funccall( ::pg_query::FuncCall* funccall) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.funccall_); } _impl_.funccall_ = funccall; if (funccall) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CallStmt.funccall) } inline ::pg_query::FuncCall* CallStmt::release_funccall() { ::pg_query::FuncCall* temp = _impl_.funccall_; _impl_.funccall_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::FuncCall* CallStmt::unsafe_arena_release_funccall() { // @@protoc_insertion_point(field_release:pg_query.CallStmt.funccall) ::pg_query::FuncCall* temp = _impl_.funccall_; _impl_.funccall_ = nullptr; return temp; } inline ::pg_query::FuncCall* CallStmt::_internal_mutable_funccall() { if (_impl_.funccall_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::FuncCall>(GetArenaForAllocation()); _impl_.funccall_ = p; } return _impl_.funccall_; } inline ::pg_query::FuncCall* CallStmt::mutable_funccall() { ::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* funccall) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.funccall_; } if (funccall) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(funccall); if (message_arena != submessage_arena) { funccall = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, funccall, submessage_arena); } } else { } _impl_.funccall_ = funccall; // @@protoc_insertion_point(field_set_allocated:pg_query.CallStmt.funccall) } // .pg_query.FuncExpr funcexpr = 2 [json_name = "funcexpr"]; inline bool CallStmt::_internal_has_funcexpr() const { return this != internal_default_instance() && _impl_.funcexpr_ != nullptr; } inline bool CallStmt::has_funcexpr() const { return _internal_has_funcexpr(); } inline void CallStmt::clear_funcexpr() { if (GetArenaForAllocation() == nullptr && _impl_.funcexpr_ != nullptr) { delete _impl_.funcexpr_; } _impl_.funcexpr_ = nullptr; } inline const ::pg_query::FuncExpr& CallStmt::_internal_funcexpr() const { const ::pg_query::FuncExpr* p = _impl_.funcexpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_FuncExpr_default_instance_); } inline const ::pg_query::FuncExpr& CallStmt::funcexpr() const { // @@protoc_insertion_point(field_get:pg_query.CallStmt.funcexpr) return _internal_funcexpr(); } inline void CallStmt::unsafe_arena_set_allocated_funcexpr( ::pg_query::FuncExpr* funcexpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.funcexpr_); } _impl_.funcexpr_ = funcexpr; if (funcexpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CallStmt.funcexpr) } inline ::pg_query::FuncExpr* CallStmt::release_funcexpr() { ::pg_query::FuncExpr* temp = _impl_.funcexpr_; _impl_.funcexpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::FuncExpr* CallStmt::unsafe_arena_release_funcexpr() { // @@protoc_insertion_point(field_release:pg_query.CallStmt.funcexpr) ::pg_query::FuncExpr* temp = _impl_.funcexpr_; _impl_.funcexpr_ = nullptr; return temp; } inline ::pg_query::FuncExpr* CallStmt::_internal_mutable_funcexpr() { if (_impl_.funcexpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::FuncExpr>(GetArenaForAllocation()); _impl_.funcexpr_ = p; } return _impl_.funcexpr_; } inline ::pg_query::FuncExpr* CallStmt::mutable_funcexpr() { ::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* funcexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.funcexpr_; } if (funcexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(funcexpr); if (message_arena != submessage_arena) { funcexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, funcexpr, submessage_arena); } } else { } _impl_.funcexpr_ = funcexpr; // @@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 _impl_.outargs_.size(); } inline int CallStmt::outargs_size() const { return _internal_outargs_size(); } inline void CallStmt::clear_outargs() { _impl_.outargs_.Clear(); } inline ::pg_query::Node* CallStmt::mutable_outargs(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CallStmt.outargs) return _impl_.outargs_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CallStmt::mutable_outargs() { // @@protoc_insertion_point(field_mutable_list:pg_query.CallStmt.outargs) return &_impl_.outargs_; } inline const ::pg_query::Node& CallStmt::_internal_outargs(int index) const { return _impl_.outargs_.Get(index); } inline const ::pg_query::Node& CallStmt::outargs(int index) const { // @@protoc_insertion_point(field_get:pg_query.CallStmt.outargs) return _internal_outargs(index); } inline ::pg_query::Node* CallStmt::_internal_add_outargs() { return _impl_.outargs_.Add(); } inline ::pg_query::Node* CallStmt::add_outargs() { ::pg_query::Node* _add = _internal_add_outargs(); // @@protoc_insertion_point(field_add:pg_query.CallStmt.outargs) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CallStmt::outargs() const { // @@protoc_insertion_point(field_list:pg_query.CallStmt.outargs) return _impl_.outargs_; } // ------------------------------------------------------------------- // AlterStatsStmt // repeated .pg_query.Node defnames = 1 [json_name = "defnames"]; inline int AlterStatsStmt::_internal_defnames_size() const { return _impl_.defnames_.size(); } inline int AlterStatsStmt::defnames_size() const { return _internal_defnames_size(); } inline void AlterStatsStmt::clear_defnames() { _impl_.defnames_.Clear(); } inline ::pg_query::Node* AlterStatsStmt::mutable_defnames(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AlterStatsStmt.defnames) return _impl_.defnames_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AlterStatsStmt::mutable_defnames() { // @@protoc_insertion_point(field_mutable_list:pg_query.AlterStatsStmt.defnames) return &_impl_.defnames_; } inline const ::pg_query::Node& AlterStatsStmt::_internal_defnames(int index) const { return _impl_.defnames_.Get(index); } inline const ::pg_query::Node& AlterStatsStmt::defnames(int index) const { // @@protoc_insertion_point(field_get:pg_query.AlterStatsStmt.defnames) return _internal_defnames(index); } inline ::pg_query::Node* AlterStatsStmt::_internal_add_defnames() { return _impl_.defnames_.Add(); } inline ::pg_query::Node* AlterStatsStmt::add_defnames() { ::pg_query::Node* _add = _internal_add_defnames(); // @@protoc_insertion_point(field_add:pg_query.AlterStatsStmt.defnames) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AlterStatsStmt::defnames() const { // @@protoc_insertion_point(field_list:pg_query.AlterStatsStmt.defnames) return _impl_.defnames_; } // int32 stxstattarget = 2 [json_name = "stxstattarget"]; inline void AlterStatsStmt::clear_stxstattarget() { _impl_.stxstattarget_ = 0; } inline int32_t AlterStatsStmt::_internal_stxstattarget() const { return _impl_.stxstattarget_; } inline int32_t AlterStatsStmt::stxstattarget() const { // @@protoc_insertion_point(field_get:pg_query.AlterStatsStmt.stxstattarget) return _internal_stxstattarget(); } inline void AlterStatsStmt::_internal_set_stxstattarget(int32_t value) { _impl_.stxstattarget_ = value; } inline void AlterStatsStmt::set_stxstattarget(int32_t value) { _internal_set_stxstattarget(value); // @@protoc_insertion_point(field_set:pg_query.AlterStatsStmt.stxstattarget) } // bool missing_ok = 3 [json_name = "missing_ok"]; inline void AlterStatsStmt::clear_missing_ok() { _impl_.missing_ok_ = false; } inline bool AlterStatsStmt::_internal_missing_ok() const { return _impl_.missing_ok_; } inline bool AlterStatsStmt::missing_ok() const { // @@protoc_insertion_point(field_get:pg_query.AlterStatsStmt.missing_ok) return _internal_missing_ok(); } inline void AlterStatsStmt::_internal_set_missing_ok(bool value) { _impl_.missing_ok_ = value; } inline void AlterStatsStmt::set_missing_ok(bool value) { _internal_set_missing_ok(value); // @@protoc_insertion_point(field_set:pg_query.AlterStatsStmt.missing_ok) } // ------------------------------------------------------------------- // A_Expr // .pg_query.A_Expr_Kind kind = 1 [json_name = "kind"]; inline void A_Expr::clear_kind() { _impl_.kind_ = 0; } inline ::pg_query::A_Expr_Kind A_Expr::_internal_kind() const { return static_cast< ::pg_query::A_Expr_Kind >(_impl_.kind_); } inline ::pg_query::A_Expr_Kind A_Expr::kind() const { // @@protoc_insertion_point(field_get:pg_query.A_Expr.kind) return _internal_kind(); } inline void A_Expr::_internal_set_kind(::pg_query::A_Expr_Kind value) { _impl_.kind_ = value; } inline void A_Expr::set_kind(::pg_query::A_Expr_Kind value) { _internal_set_kind(value); // @@protoc_insertion_point(field_set:pg_query.A_Expr.kind) } // repeated .pg_query.Node name = 2 [json_name = "name"]; inline int A_Expr::_internal_name_size() const { return _impl_.name_.size(); } inline int A_Expr::name_size() const { return _internal_name_size(); } inline void A_Expr::clear_name() { _impl_.name_.Clear(); } inline ::pg_query::Node* A_Expr::mutable_name(int index) { // @@protoc_insertion_point(field_mutable:pg_query.A_Expr.name) return _impl_.name_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* A_Expr::mutable_name() { // @@protoc_insertion_point(field_mutable_list:pg_query.A_Expr.name) return &_impl_.name_; } inline const ::pg_query::Node& A_Expr::_internal_name(int index) const { return _impl_.name_.Get(index); } inline const ::pg_query::Node& A_Expr::name(int index) const { // @@protoc_insertion_point(field_get:pg_query.A_Expr.name) return _internal_name(index); } inline ::pg_query::Node* A_Expr::_internal_add_name() { return _impl_.name_.Add(); } inline ::pg_query::Node* A_Expr::add_name() { ::pg_query::Node* _add = _internal_add_name(); // @@protoc_insertion_point(field_add:pg_query.A_Expr.name) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& A_Expr::name() const { // @@protoc_insertion_point(field_list:pg_query.A_Expr.name) return _impl_.name_; } // .pg_query.Node lexpr = 3 [json_name = "lexpr"]; inline bool A_Expr::_internal_has_lexpr() const { return this != internal_default_instance() && _impl_.lexpr_ != nullptr; } inline bool A_Expr::has_lexpr() const { return _internal_has_lexpr(); } inline void A_Expr::clear_lexpr() { if (GetArenaForAllocation() == nullptr && _impl_.lexpr_ != nullptr) { delete _impl_.lexpr_; } _impl_.lexpr_ = nullptr; } inline const ::pg_query::Node& A_Expr::_internal_lexpr() const { const ::pg_query::Node* p = _impl_.lexpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& A_Expr::lexpr() const { // @@protoc_insertion_point(field_get:pg_query.A_Expr.lexpr) return _internal_lexpr(); } inline void A_Expr::unsafe_arena_set_allocated_lexpr( ::pg_query::Node* lexpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.lexpr_); } _impl_.lexpr_ = lexpr; if (lexpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.A_Expr.lexpr) } inline ::pg_query::Node* A_Expr::release_lexpr() { ::pg_query::Node* temp = _impl_.lexpr_; _impl_.lexpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* A_Expr::unsafe_arena_release_lexpr() { // @@protoc_insertion_point(field_release:pg_query.A_Expr.lexpr) ::pg_query::Node* temp = _impl_.lexpr_; _impl_.lexpr_ = nullptr; return temp; } inline ::pg_query::Node* A_Expr::_internal_mutable_lexpr() { if (_impl_.lexpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.lexpr_ = p; } return _impl_.lexpr_; } inline ::pg_query::Node* A_Expr::mutable_lexpr() { ::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* lexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.lexpr_; } if (lexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(lexpr); if (message_arena != submessage_arena) { lexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, lexpr, submessage_arena); } } else { } _impl_.lexpr_ = lexpr; // @@protoc_insertion_point(field_set_allocated:pg_query.A_Expr.lexpr) } // .pg_query.Node rexpr = 4 [json_name = "rexpr"]; inline bool A_Expr::_internal_has_rexpr() const { return this != internal_default_instance() && _impl_.rexpr_ != nullptr; } inline bool A_Expr::has_rexpr() const { return _internal_has_rexpr(); } inline void A_Expr::clear_rexpr() { if (GetArenaForAllocation() == nullptr && _impl_.rexpr_ != nullptr) { delete _impl_.rexpr_; } _impl_.rexpr_ = nullptr; } inline const ::pg_query::Node& A_Expr::_internal_rexpr() const { const ::pg_query::Node* p = _impl_.rexpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& A_Expr::rexpr() const { // @@protoc_insertion_point(field_get:pg_query.A_Expr.rexpr) return _internal_rexpr(); } inline void A_Expr::unsafe_arena_set_allocated_rexpr( ::pg_query::Node* rexpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.rexpr_); } _impl_.rexpr_ = rexpr; if (rexpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.A_Expr.rexpr) } inline ::pg_query::Node* A_Expr::release_rexpr() { ::pg_query::Node* temp = _impl_.rexpr_; _impl_.rexpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* A_Expr::unsafe_arena_release_rexpr() { // @@protoc_insertion_point(field_release:pg_query.A_Expr.rexpr) ::pg_query::Node* temp = _impl_.rexpr_; _impl_.rexpr_ = nullptr; return temp; } inline ::pg_query::Node* A_Expr::_internal_mutable_rexpr() { if (_impl_.rexpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.rexpr_ = p; } return _impl_.rexpr_; } inline ::pg_query::Node* A_Expr::mutable_rexpr() { ::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* rexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.rexpr_; } if (rexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(rexpr); if (message_arena != submessage_arena) { rexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, rexpr, submessage_arena); } } else { } _impl_.rexpr_ = rexpr; // @@protoc_insertion_point(field_set_allocated:pg_query.A_Expr.rexpr) } // int32 location = 5 [json_name = "location"]; inline void A_Expr::clear_location() { _impl_.location_ = 0; } inline int32_t A_Expr::_internal_location() const { return _impl_.location_; } inline int32_t A_Expr::location() const { // @@protoc_insertion_point(field_get:pg_query.A_Expr.location) return _internal_location(); } inline void A_Expr::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void A_Expr::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.A_Expr.location) } // ------------------------------------------------------------------- // ColumnRef // repeated .pg_query.Node fields = 1 [json_name = "fields"]; inline int ColumnRef::_internal_fields_size() const { return _impl_.fields_.size(); } inline int ColumnRef::fields_size() const { return _internal_fields_size(); } inline void ColumnRef::clear_fields() { _impl_.fields_.Clear(); } inline ::pg_query::Node* ColumnRef::mutable_fields(int index) { // @@protoc_insertion_point(field_mutable:pg_query.ColumnRef.fields) return _impl_.fields_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* ColumnRef::mutable_fields() { // @@protoc_insertion_point(field_mutable_list:pg_query.ColumnRef.fields) return &_impl_.fields_; } inline const ::pg_query::Node& ColumnRef::_internal_fields(int index) const { return _impl_.fields_.Get(index); } inline const ::pg_query::Node& ColumnRef::fields(int index) const { // @@protoc_insertion_point(field_get:pg_query.ColumnRef.fields) return _internal_fields(index); } inline ::pg_query::Node* ColumnRef::_internal_add_fields() { return _impl_.fields_.Add(); } inline ::pg_query::Node* ColumnRef::add_fields() { ::pg_query::Node* _add = _internal_add_fields(); // @@protoc_insertion_point(field_add:pg_query.ColumnRef.fields) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& ColumnRef::fields() const { // @@protoc_insertion_point(field_list:pg_query.ColumnRef.fields) return _impl_.fields_; } // int32 location = 2 [json_name = "location"]; inline void ColumnRef::clear_location() { _impl_.location_ = 0; } inline int32_t ColumnRef::_internal_location() const { return _impl_.location_; } inline int32_t ColumnRef::location() const { // @@protoc_insertion_point(field_get:pg_query.ColumnRef.location) return _internal_location(); } inline void ColumnRef::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void ColumnRef::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.ColumnRef.location) } // ------------------------------------------------------------------- // ParamRef // int32 number = 1 [json_name = "number"]; inline void ParamRef::clear_number() { _impl_.number_ = 0; } inline int32_t ParamRef::_internal_number() const { return _impl_.number_; } inline int32_t ParamRef::number() const { // @@protoc_insertion_point(field_get:pg_query.ParamRef.number) return _internal_number(); } inline void ParamRef::_internal_set_number(int32_t value) { _impl_.number_ = value; } inline void ParamRef::set_number(int32_t value) { _internal_set_number(value); // @@protoc_insertion_point(field_set:pg_query.ParamRef.number) } // int32 location = 2 [json_name = "location"]; inline void ParamRef::clear_location() { _impl_.location_ = 0; } inline int32_t ParamRef::_internal_location() const { return _impl_.location_; } inline int32_t ParamRef::location() const { // @@protoc_insertion_point(field_get:pg_query.ParamRef.location) return _internal_location(); } inline void ParamRef::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void ParamRef::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.ParamRef.location) } // ------------------------------------------------------------------- // FuncCall // repeated .pg_query.Node funcname = 1 [json_name = "funcname"]; inline int FuncCall::_internal_funcname_size() const { return _impl_.funcname_.size(); } inline int FuncCall::funcname_size() const { return _internal_funcname_size(); } inline void FuncCall::clear_funcname() { _impl_.funcname_.Clear(); } inline ::pg_query::Node* FuncCall::mutable_funcname(int index) { // @@protoc_insertion_point(field_mutable:pg_query.FuncCall.funcname) return _impl_.funcname_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* FuncCall::mutable_funcname() { // @@protoc_insertion_point(field_mutable_list:pg_query.FuncCall.funcname) return &_impl_.funcname_; } inline const ::pg_query::Node& FuncCall::_internal_funcname(int index) const { return _impl_.funcname_.Get(index); } inline const ::pg_query::Node& FuncCall::funcname(int index) const { // @@protoc_insertion_point(field_get:pg_query.FuncCall.funcname) return _internal_funcname(index); } inline ::pg_query::Node* FuncCall::_internal_add_funcname() { return _impl_.funcname_.Add(); } inline ::pg_query::Node* FuncCall::add_funcname() { ::pg_query::Node* _add = _internal_add_funcname(); // @@protoc_insertion_point(field_add:pg_query.FuncCall.funcname) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& FuncCall::funcname() const { // @@protoc_insertion_point(field_list:pg_query.FuncCall.funcname) return _impl_.funcname_; } // repeated .pg_query.Node args = 2 [json_name = "args"]; inline int FuncCall::_internal_args_size() const { return _impl_.args_.size(); } inline int FuncCall::args_size() const { return _internal_args_size(); } inline void FuncCall::clear_args() { _impl_.args_.Clear(); } inline ::pg_query::Node* FuncCall::mutable_args(int index) { // @@protoc_insertion_point(field_mutable:pg_query.FuncCall.args) return _impl_.args_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* FuncCall::mutable_args() { // @@protoc_insertion_point(field_mutable_list:pg_query.FuncCall.args) return &_impl_.args_; } inline const ::pg_query::Node& FuncCall::_internal_args(int index) const { return _impl_.args_.Get(index); } inline const ::pg_query::Node& FuncCall::args(int index) const { // @@protoc_insertion_point(field_get:pg_query.FuncCall.args) return _internal_args(index); } inline ::pg_query::Node* FuncCall::_internal_add_args() { return _impl_.args_.Add(); } inline ::pg_query::Node* FuncCall::add_args() { ::pg_query::Node* _add = _internal_add_args(); // @@protoc_insertion_point(field_add:pg_query.FuncCall.args) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& FuncCall::args() const { // @@protoc_insertion_point(field_list:pg_query.FuncCall.args) return _impl_.args_; } // repeated .pg_query.Node agg_order = 3 [json_name = "agg_order"]; inline int FuncCall::_internal_agg_order_size() const { return _impl_.agg_order_.size(); } inline int FuncCall::agg_order_size() const { return _internal_agg_order_size(); } inline void FuncCall::clear_agg_order() { _impl_.agg_order_.Clear(); } inline ::pg_query::Node* FuncCall::mutable_agg_order(int index) { // @@protoc_insertion_point(field_mutable:pg_query.FuncCall.agg_order) return _impl_.agg_order_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* FuncCall::mutable_agg_order() { // @@protoc_insertion_point(field_mutable_list:pg_query.FuncCall.agg_order) return &_impl_.agg_order_; } inline const ::pg_query::Node& FuncCall::_internal_agg_order(int index) const { return _impl_.agg_order_.Get(index); } inline const ::pg_query::Node& FuncCall::agg_order(int index) const { // @@protoc_insertion_point(field_get:pg_query.FuncCall.agg_order) return _internal_agg_order(index); } inline ::pg_query::Node* FuncCall::_internal_add_agg_order() { return _impl_.agg_order_.Add(); } inline ::pg_query::Node* FuncCall::add_agg_order() { ::pg_query::Node* _add = _internal_add_agg_order(); // @@protoc_insertion_point(field_add:pg_query.FuncCall.agg_order) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& FuncCall::agg_order() const { // @@protoc_insertion_point(field_list:pg_query.FuncCall.agg_order) return _impl_.agg_order_; } // .pg_query.Node agg_filter = 4 [json_name = "agg_filter"]; inline bool FuncCall::_internal_has_agg_filter() const { return this != internal_default_instance() && _impl_.agg_filter_ != nullptr; } inline bool FuncCall::has_agg_filter() const { return _internal_has_agg_filter(); } inline void FuncCall::clear_agg_filter() { if (GetArenaForAllocation() == nullptr && _impl_.agg_filter_ != nullptr) { delete _impl_.agg_filter_; } _impl_.agg_filter_ = nullptr; } inline const ::pg_query::Node& FuncCall::_internal_agg_filter() const { const ::pg_query::Node* p = _impl_.agg_filter_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& FuncCall::agg_filter() const { // @@protoc_insertion_point(field_get:pg_query.FuncCall.agg_filter) return _internal_agg_filter(); } inline void FuncCall::unsafe_arena_set_allocated_agg_filter( ::pg_query::Node* agg_filter) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.agg_filter_); } _impl_.agg_filter_ = agg_filter; if (agg_filter) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FuncCall.agg_filter) } inline ::pg_query::Node* FuncCall::release_agg_filter() { ::pg_query::Node* temp = _impl_.agg_filter_; _impl_.agg_filter_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* FuncCall::unsafe_arena_release_agg_filter() { // @@protoc_insertion_point(field_release:pg_query.FuncCall.agg_filter) ::pg_query::Node* temp = _impl_.agg_filter_; _impl_.agg_filter_ = nullptr; return temp; } inline ::pg_query::Node* FuncCall::_internal_mutable_agg_filter() { if (_impl_.agg_filter_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.agg_filter_ = p; } return _impl_.agg_filter_; } inline ::pg_query::Node* FuncCall::mutable_agg_filter() { ::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* agg_filter) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.agg_filter_; } if (agg_filter) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(agg_filter); if (message_arena != submessage_arena) { agg_filter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, agg_filter, submessage_arena); } } else { } _impl_.agg_filter_ = agg_filter; // @@protoc_insertion_point(field_set_allocated:pg_query.FuncCall.agg_filter) } // .pg_query.WindowDef over = 5 [json_name = "over"]; inline bool FuncCall::_internal_has_over() const { return this != internal_default_instance() && _impl_.over_ != nullptr; } inline bool FuncCall::has_over() const { return _internal_has_over(); } inline void FuncCall::clear_over() { if (GetArenaForAllocation() == nullptr && _impl_.over_ != nullptr) { delete _impl_.over_; } _impl_.over_ = nullptr; } inline const ::pg_query::WindowDef& FuncCall::_internal_over() const { const ::pg_query::WindowDef* p = _impl_.over_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_WindowDef_default_instance_); } inline const ::pg_query::WindowDef& FuncCall::over() const { // @@protoc_insertion_point(field_get:pg_query.FuncCall.over) return _internal_over(); } inline void FuncCall::unsafe_arena_set_allocated_over( ::pg_query::WindowDef* over) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.over_); } _impl_.over_ = over; if (over) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FuncCall.over) } inline ::pg_query::WindowDef* FuncCall::release_over() { ::pg_query::WindowDef* temp = _impl_.over_; _impl_.over_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::WindowDef* FuncCall::unsafe_arena_release_over() { // @@protoc_insertion_point(field_release:pg_query.FuncCall.over) ::pg_query::WindowDef* temp = _impl_.over_; _impl_.over_ = nullptr; return temp; } inline ::pg_query::WindowDef* FuncCall::_internal_mutable_over() { if (_impl_.over_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::WindowDef>(GetArenaForAllocation()); _impl_.over_ = p; } return _impl_.over_; } inline ::pg_query::WindowDef* FuncCall::mutable_over() { ::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* over) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.over_; } if (over) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(over); if (message_arena != submessage_arena) { over = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, over, submessage_arena); } } else { } _impl_.over_ = over; // @@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() { _impl_.agg_within_group_ = false; } inline bool FuncCall::_internal_agg_within_group() const { return _impl_.agg_within_group_; } inline bool FuncCall::agg_within_group() const { // @@protoc_insertion_point(field_get:pg_query.FuncCall.agg_within_group) return _internal_agg_within_group(); } inline void FuncCall::_internal_set_agg_within_group(bool value) { _impl_.agg_within_group_ = value; } inline void FuncCall::set_agg_within_group(bool value) { _internal_set_agg_within_group(value); // @@protoc_insertion_point(field_set:pg_query.FuncCall.agg_within_group) } // bool agg_star = 7 [json_name = "agg_star"]; inline void FuncCall::clear_agg_star() { _impl_.agg_star_ = false; } inline bool FuncCall::_internal_agg_star() const { return _impl_.agg_star_; } inline bool FuncCall::agg_star() const { // @@protoc_insertion_point(field_get:pg_query.FuncCall.agg_star) return _internal_agg_star(); } inline void FuncCall::_internal_set_agg_star(bool value) { _impl_.agg_star_ = value; } inline void FuncCall::set_agg_star(bool value) { _internal_set_agg_star(value); // @@protoc_insertion_point(field_set:pg_query.FuncCall.agg_star) } // bool agg_distinct = 8 [json_name = "agg_distinct"]; inline void FuncCall::clear_agg_distinct() { _impl_.agg_distinct_ = false; } inline bool FuncCall::_internal_agg_distinct() const { return _impl_.agg_distinct_; } inline bool FuncCall::agg_distinct() const { // @@protoc_insertion_point(field_get:pg_query.FuncCall.agg_distinct) return _internal_agg_distinct(); } inline void FuncCall::_internal_set_agg_distinct(bool value) { _impl_.agg_distinct_ = value; } inline void FuncCall::set_agg_distinct(bool value) { _internal_set_agg_distinct(value); // @@protoc_insertion_point(field_set:pg_query.FuncCall.agg_distinct) } // bool func_variadic = 9 [json_name = "func_variadic"]; inline void FuncCall::clear_func_variadic() { _impl_.func_variadic_ = false; } inline bool FuncCall::_internal_func_variadic() const { return _impl_.func_variadic_; } inline bool FuncCall::func_variadic() const { // @@protoc_insertion_point(field_get:pg_query.FuncCall.func_variadic) return _internal_func_variadic(); } inline void FuncCall::_internal_set_func_variadic(bool value) { _impl_.func_variadic_ = value; } inline void FuncCall::set_func_variadic(bool value) { _internal_set_func_variadic(value); // @@protoc_insertion_point(field_set:pg_query.FuncCall.func_variadic) } // .pg_query.CoercionForm funcformat = 10 [json_name = "funcformat"]; inline void FuncCall::clear_funcformat() { _impl_.funcformat_ = 0; } inline ::pg_query::CoercionForm FuncCall::_internal_funcformat() const { return static_cast< ::pg_query::CoercionForm >(_impl_.funcformat_); } inline ::pg_query::CoercionForm FuncCall::funcformat() const { // @@protoc_insertion_point(field_get:pg_query.FuncCall.funcformat) return _internal_funcformat(); } inline void FuncCall::_internal_set_funcformat(::pg_query::CoercionForm value) { _impl_.funcformat_ = value; } inline void FuncCall::set_funcformat(::pg_query::CoercionForm value) { _internal_set_funcformat(value); // @@protoc_insertion_point(field_set:pg_query.FuncCall.funcformat) } // int32 location = 11 [json_name = "location"]; inline void FuncCall::clear_location() { _impl_.location_ = 0; } inline int32_t FuncCall::_internal_location() const { return _impl_.location_; } inline int32_t FuncCall::location() const { // @@protoc_insertion_point(field_get:pg_query.FuncCall.location) return _internal_location(); } inline void FuncCall::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void FuncCall::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.FuncCall.location) } // ------------------------------------------------------------------- // A_Star // ------------------------------------------------------------------- // A_Indices // bool is_slice = 1 [json_name = "is_slice"]; inline void A_Indices::clear_is_slice() { _impl_.is_slice_ = false; } inline bool A_Indices::_internal_is_slice() const { return _impl_.is_slice_; } inline bool A_Indices::is_slice() const { // @@protoc_insertion_point(field_get:pg_query.A_Indices.is_slice) return _internal_is_slice(); } inline void A_Indices::_internal_set_is_slice(bool value) { _impl_.is_slice_ = value; } inline void A_Indices::set_is_slice(bool value) { _internal_set_is_slice(value); // @@protoc_insertion_point(field_set:pg_query.A_Indices.is_slice) } // .pg_query.Node lidx = 2 [json_name = "lidx"]; inline bool A_Indices::_internal_has_lidx() const { return this != internal_default_instance() && _impl_.lidx_ != nullptr; } inline bool A_Indices::has_lidx() const { return _internal_has_lidx(); } inline void A_Indices::clear_lidx() { if (GetArenaForAllocation() == nullptr && _impl_.lidx_ != nullptr) { delete _impl_.lidx_; } _impl_.lidx_ = nullptr; } inline const ::pg_query::Node& A_Indices::_internal_lidx() const { const ::pg_query::Node* p = _impl_.lidx_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& A_Indices::lidx() const { // @@protoc_insertion_point(field_get:pg_query.A_Indices.lidx) return _internal_lidx(); } inline void A_Indices::unsafe_arena_set_allocated_lidx( ::pg_query::Node* lidx) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.lidx_); } _impl_.lidx_ = lidx; if (lidx) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.A_Indices.lidx) } inline ::pg_query::Node* A_Indices::release_lidx() { ::pg_query::Node* temp = _impl_.lidx_; _impl_.lidx_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* A_Indices::unsafe_arena_release_lidx() { // @@protoc_insertion_point(field_release:pg_query.A_Indices.lidx) ::pg_query::Node* temp = _impl_.lidx_; _impl_.lidx_ = nullptr; return temp; } inline ::pg_query::Node* A_Indices::_internal_mutable_lidx() { if (_impl_.lidx_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.lidx_ = p; } return _impl_.lidx_; } inline ::pg_query::Node* A_Indices::mutable_lidx() { ::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* lidx) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.lidx_; } if (lidx) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(lidx); if (message_arena != submessage_arena) { lidx = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, lidx, submessage_arena); } } else { } _impl_.lidx_ = lidx; // @@protoc_insertion_point(field_set_allocated:pg_query.A_Indices.lidx) } // .pg_query.Node uidx = 3 [json_name = "uidx"]; inline bool A_Indices::_internal_has_uidx() const { return this != internal_default_instance() && _impl_.uidx_ != nullptr; } inline bool A_Indices::has_uidx() const { return _internal_has_uidx(); } inline void A_Indices::clear_uidx() { if (GetArenaForAllocation() == nullptr && _impl_.uidx_ != nullptr) { delete _impl_.uidx_; } _impl_.uidx_ = nullptr; } inline const ::pg_query::Node& A_Indices::_internal_uidx() const { const ::pg_query::Node* p = _impl_.uidx_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& A_Indices::uidx() const { // @@protoc_insertion_point(field_get:pg_query.A_Indices.uidx) return _internal_uidx(); } inline void A_Indices::unsafe_arena_set_allocated_uidx( ::pg_query::Node* uidx) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.uidx_); } _impl_.uidx_ = uidx; if (uidx) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.A_Indices.uidx) } inline ::pg_query::Node* A_Indices::release_uidx() { ::pg_query::Node* temp = _impl_.uidx_; _impl_.uidx_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* A_Indices::unsafe_arena_release_uidx() { // @@protoc_insertion_point(field_release:pg_query.A_Indices.uidx) ::pg_query::Node* temp = _impl_.uidx_; _impl_.uidx_ = nullptr; return temp; } inline ::pg_query::Node* A_Indices::_internal_mutable_uidx() { if (_impl_.uidx_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.uidx_ = p; } return _impl_.uidx_; } inline ::pg_query::Node* A_Indices::mutable_uidx() { ::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* uidx) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.uidx_; } if (uidx) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(uidx); if (message_arena != submessage_arena) { uidx = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, uidx, submessage_arena); } } else { } _impl_.uidx_ = uidx; // @@protoc_insertion_point(field_set_allocated:pg_query.A_Indices.uidx) } // ------------------------------------------------------------------- // A_Indirection // .pg_query.Node arg = 1 [json_name = "arg"]; inline bool A_Indirection::_internal_has_arg() const { return this != internal_default_instance() && _impl_.arg_ != nullptr; } inline bool A_Indirection::has_arg() const { return _internal_has_arg(); } inline void A_Indirection::clear_arg() { if (GetArenaForAllocation() == nullptr && _impl_.arg_ != nullptr) { delete _impl_.arg_; } _impl_.arg_ = nullptr; } inline const ::pg_query::Node& A_Indirection::_internal_arg() const { const ::pg_query::Node* p = _impl_.arg_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& A_Indirection::arg() const { // @@protoc_insertion_point(field_get:pg_query.A_Indirection.arg) return _internal_arg(); } inline void A_Indirection::unsafe_arena_set_allocated_arg( ::pg_query::Node* arg) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.arg_); } _impl_.arg_ = arg; if (arg) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.A_Indirection.arg) } inline ::pg_query::Node* A_Indirection::release_arg() { ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* A_Indirection::unsafe_arena_release_arg() { // @@protoc_insertion_point(field_release:pg_query.A_Indirection.arg) ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; return temp; } inline ::pg_query::Node* A_Indirection::_internal_mutable_arg() { if (_impl_.arg_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.arg_ = p; } return _impl_.arg_; } inline ::pg_query::Node* A_Indirection::mutable_arg() { ::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* arg) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.arg_; } if (arg) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(arg); if (message_arena != submessage_arena) { arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, arg, submessage_arena); } } else { } _impl_.arg_ = arg; // @@protoc_insertion_point(field_set_allocated:pg_query.A_Indirection.arg) } // repeated .pg_query.Node indirection = 2 [json_name = "indirection"]; inline int A_Indirection::_internal_indirection_size() const { return _impl_.indirection_.size(); } inline int A_Indirection::indirection_size() const { return _internal_indirection_size(); } inline void A_Indirection::clear_indirection() { _impl_.indirection_.Clear(); } inline ::pg_query::Node* A_Indirection::mutable_indirection(int index) { // @@protoc_insertion_point(field_mutable:pg_query.A_Indirection.indirection) return _impl_.indirection_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* A_Indirection::mutable_indirection() { // @@protoc_insertion_point(field_mutable_list:pg_query.A_Indirection.indirection) return &_impl_.indirection_; } inline const ::pg_query::Node& A_Indirection::_internal_indirection(int index) const { return _impl_.indirection_.Get(index); } inline const ::pg_query::Node& A_Indirection::indirection(int index) const { // @@protoc_insertion_point(field_get:pg_query.A_Indirection.indirection) return _internal_indirection(index); } inline ::pg_query::Node* A_Indirection::_internal_add_indirection() { return _impl_.indirection_.Add(); } inline ::pg_query::Node* A_Indirection::add_indirection() { ::pg_query::Node* _add = _internal_add_indirection(); // @@protoc_insertion_point(field_add:pg_query.A_Indirection.indirection) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& A_Indirection::indirection() const { // @@protoc_insertion_point(field_list:pg_query.A_Indirection.indirection) return _impl_.indirection_; } // ------------------------------------------------------------------- // A_ArrayExpr // repeated .pg_query.Node elements = 1 [json_name = "elements"]; inline int A_ArrayExpr::_internal_elements_size() const { return _impl_.elements_.size(); } inline int A_ArrayExpr::elements_size() const { return _internal_elements_size(); } inline void A_ArrayExpr::clear_elements() { _impl_.elements_.Clear(); } inline ::pg_query::Node* A_ArrayExpr::mutable_elements(int index) { // @@protoc_insertion_point(field_mutable:pg_query.A_ArrayExpr.elements) return _impl_.elements_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* A_ArrayExpr::mutable_elements() { // @@protoc_insertion_point(field_mutable_list:pg_query.A_ArrayExpr.elements) return &_impl_.elements_; } inline const ::pg_query::Node& A_ArrayExpr::_internal_elements(int index) const { return _impl_.elements_.Get(index); } inline const ::pg_query::Node& A_ArrayExpr::elements(int index) const { // @@protoc_insertion_point(field_get:pg_query.A_ArrayExpr.elements) return _internal_elements(index); } inline ::pg_query::Node* A_ArrayExpr::_internal_add_elements() { return _impl_.elements_.Add(); } inline ::pg_query::Node* A_ArrayExpr::add_elements() { ::pg_query::Node* _add = _internal_add_elements(); // @@protoc_insertion_point(field_add:pg_query.A_ArrayExpr.elements) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& A_ArrayExpr::elements() const { // @@protoc_insertion_point(field_list:pg_query.A_ArrayExpr.elements) return _impl_.elements_; } // int32 location = 2 [json_name = "location"]; inline void A_ArrayExpr::clear_location() { _impl_.location_ = 0; } inline int32_t A_ArrayExpr::_internal_location() const { return _impl_.location_; } inline int32_t A_ArrayExpr::location() const { // @@protoc_insertion_point(field_get:pg_query.A_ArrayExpr.location) return _internal_location(); } inline void A_ArrayExpr::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void A_ArrayExpr::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.A_ArrayExpr.location) } // ------------------------------------------------------------------- // ResTarget // string name = 1 [json_name = "name"]; inline void ResTarget::clear_name() { _impl_.name_.ClearToEmpty(); } inline const std::string& ResTarget::name() const { // @@protoc_insertion_point(field_get:pg_query.ResTarget.name) return _internal_name(); } template inline PROTOBUF_ALWAYS_INLINE void ResTarget::set_name(ArgT0&& arg0, ArgT... args) { _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.ResTarget.name) } inline std::string* ResTarget::mutable_name() { 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 { return _impl_.name_.Get(); } inline void ResTarget::_internal_set_name(const std::string& value) { _impl_.name_.Set(value, GetArenaForAllocation()); } inline std::string* ResTarget::_internal_mutable_name() { return _impl_.name_.Mutable(GetArenaForAllocation()); } inline std::string* ResTarget::release_name() { // @@protoc_insertion_point(field_release:pg_query.ResTarget.name) return _impl_.name_.Release(); } inline void ResTarget::set_allocated_name(std::string* name) { if (name != nullptr) { } else { } _impl_.name_.SetAllocated(name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.name_.IsDefault()) { _impl_.name_.Set("", GetArenaForAllocation()); } #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 _impl_.indirection_.size(); } inline int ResTarget::indirection_size() const { return _internal_indirection_size(); } inline void ResTarget::clear_indirection() { _impl_.indirection_.Clear(); } inline ::pg_query::Node* ResTarget::mutable_indirection(int index) { // @@protoc_insertion_point(field_mutable:pg_query.ResTarget.indirection) return _impl_.indirection_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* ResTarget::mutable_indirection() { // @@protoc_insertion_point(field_mutable_list:pg_query.ResTarget.indirection) return &_impl_.indirection_; } inline const ::pg_query::Node& ResTarget::_internal_indirection(int index) const { return _impl_.indirection_.Get(index); } inline const ::pg_query::Node& ResTarget::indirection(int index) const { // @@protoc_insertion_point(field_get:pg_query.ResTarget.indirection) return _internal_indirection(index); } inline ::pg_query::Node* ResTarget::_internal_add_indirection() { return _impl_.indirection_.Add(); } inline ::pg_query::Node* ResTarget::add_indirection() { ::pg_query::Node* _add = _internal_add_indirection(); // @@protoc_insertion_point(field_add:pg_query.ResTarget.indirection) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& ResTarget::indirection() const { // @@protoc_insertion_point(field_list:pg_query.ResTarget.indirection) return _impl_.indirection_; } // .pg_query.Node val = 3 [json_name = "val"]; inline bool ResTarget::_internal_has_val() const { return this != internal_default_instance() && _impl_.val_ != nullptr; } inline bool ResTarget::has_val() const { return _internal_has_val(); } inline void ResTarget::clear_val() { if (GetArenaForAllocation() == nullptr && _impl_.val_ != nullptr) { delete _impl_.val_; } _impl_.val_ = nullptr; } inline const ::pg_query::Node& ResTarget::_internal_val() const { const ::pg_query::Node* p = _impl_.val_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& ResTarget::val() const { // @@protoc_insertion_point(field_get:pg_query.ResTarget.val) return _internal_val(); } inline void ResTarget::unsafe_arena_set_allocated_val( ::pg_query::Node* val) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.val_); } _impl_.val_ = val; if (val) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ResTarget.val) } inline ::pg_query::Node* ResTarget::release_val() { ::pg_query::Node* temp = _impl_.val_; _impl_.val_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* ResTarget::unsafe_arena_release_val() { // @@protoc_insertion_point(field_release:pg_query.ResTarget.val) ::pg_query::Node* temp = _impl_.val_; _impl_.val_ = nullptr; return temp; } inline ::pg_query::Node* ResTarget::_internal_mutable_val() { if (_impl_.val_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.val_ = p; } return _impl_.val_; } inline ::pg_query::Node* ResTarget::mutable_val() { ::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* val) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.val_; } if (val) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(val); if (message_arena != submessage_arena) { val = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, val, submessage_arena); } } else { } _impl_.val_ = val; // @@protoc_insertion_point(field_set_allocated:pg_query.ResTarget.val) } // int32 location = 4 [json_name = "location"]; inline void ResTarget::clear_location() { _impl_.location_ = 0; } inline int32_t ResTarget::_internal_location() const { return _impl_.location_; } inline int32_t ResTarget::location() const { // @@protoc_insertion_point(field_get:pg_query.ResTarget.location) return _internal_location(); } inline void ResTarget::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void ResTarget::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.ResTarget.location) } // ------------------------------------------------------------------- // MultiAssignRef // .pg_query.Node source = 1 [json_name = "source"]; inline bool MultiAssignRef::_internal_has_source() const { return this != internal_default_instance() && _impl_.source_ != nullptr; } inline bool MultiAssignRef::has_source() const { return _internal_has_source(); } inline void MultiAssignRef::clear_source() { if (GetArenaForAllocation() == nullptr && _impl_.source_ != nullptr) { delete _impl_.source_; } _impl_.source_ = nullptr; } inline const ::pg_query::Node& MultiAssignRef::_internal_source() const { const ::pg_query::Node* p = _impl_.source_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& MultiAssignRef::source() const { // @@protoc_insertion_point(field_get:pg_query.MultiAssignRef.source) return _internal_source(); } inline void MultiAssignRef::unsafe_arena_set_allocated_source( ::pg_query::Node* source) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.source_); } _impl_.source_ = source; if (source) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.MultiAssignRef.source) } inline ::pg_query::Node* MultiAssignRef::release_source() { ::pg_query::Node* temp = _impl_.source_; _impl_.source_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* MultiAssignRef::unsafe_arena_release_source() { // @@protoc_insertion_point(field_release:pg_query.MultiAssignRef.source) ::pg_query::Node* temp = _impl_.source_; _impl_.source_ = nullptr; return temp; } inline ::pg_query::Node* MultiAssignRef::_internal_mutable_source() { if (_impl_.source_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.source_ = p; } return _impl_.source_; } inline ::pg_query::Node* MultiAssignRef::mutable_source() { ::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* source) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.source_; } if (source) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(source); if (message_arena != submessage_arena) { source = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, source, submessage_arena); } } else { } _impl_.source_ = source; // @@protoc_insertion_point(field_set_allocated:pg_query.MultiAssignRef.source) } // int32 colno = 2 [json_name = "colno"]; inline void MultiAssignRef::clear_colno() { _impl_.colno_ = 0; } inline int32_t MultiAssignRef::_internal_colno() const { return _impl_.colno_; } inline int32_t MultiAssignRef::colno() const { // @@protoc_insertion_point(field_get:pg_query.MultiAssignRef.colno) return _internal_colno(); } inline void MultiAssignRef::_internal_set_colno(int32_t value) { _impl_.colno_ = value; } inline void MultiAssignRef::set_colno(int32_t value) { _internal_set_colno(value); // @@protoc_insertion_point(field_set:pg_query.MultiAssignRef.colno) } // int32 ncolumns = 3 [json_name = "ncolumns"]; inline void MultiAssignRef::clear_ncolumns() { _impl_.ncolumns_ = 0; } inline int32_t MultiAssignRef::_internal_ncolumns() const { return _impl_.ncolumns_; } inline int32_t MultiAssignRef::ncolumns() const { // @@protoc_insertion_point(field_get:pg_query.MultiAssignRef.ncolumns) return _internal_ncolumns(); } inline void MultiAssignRef::_internal_set_ncolumns(int32_t value) { _impl_.ncolumns_ = value; } inline void MultiAssignRef::set_ncolumns(int32_t value) { _internal_set_ncolumns(value); // @@protoc_insertion_point(field_set:pg_query.MultiAssignRef.ncolumns) } // ------------------------------------------------------------------- // TypeCast // .pg_query.Node arg = 1 [json_name = "arg"]; inline bool TypeCast::_internal_has_arg() const { return this != internal_default_instance() && _impl_.arg_ != nullptr; } inline bool TypeCast::has_arg() const { return _internal_has_arg(); } inline void TypeCast::clear_arg() { if (GetArenaForAllocation() == nullptr && _impl_.arg_ != nullptr) { delete _impl_.arg_; } _impl_.arg_ = nullptr; } inline const ::pg_query::Node& TypeCast::_internal_arg() const { const ::pg_query::Node* p = _impl_.arg_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& TypeCast::arg() const { // @@protoc_insertion_point(field_get:pg_query.TypeCast.arg) return _internal_arg(); } inline void TypeCast::unsafe_arena_set_allocated_arg( ::pg_query::Node* arg) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.arg_); } _impl_.arg_ = arg; if (arg) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.TypeCast.arg) } inline ::pg_query::Node* TypeCast::release_arg() { ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* TypeCast::unsafe_arena_release_arg() { // @@protoc_insertion_point(field_release:pg_query.TypeCast.arg) ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; return temp; } inline ::pg_query::Node* TypeCast::_internal_mutable_arg() { if (_impl_.arg_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.arg_ = p; } return _impl_.arg_; } inline ::pg_query::Node* TypeCast::mutable_arg() { ::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* arg) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.arg_; } if (arg) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(arg); if (message_arena != submessage_arena) { arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, arg, submessage_arena); } } else { } _impl_.arg_ = arg; // @@protoc_insertion_point(field_set_allocated:pg_query.TypeCast.arg) } // .pg_query.TypeName type_name = 2 [json_name = "typeName"]; inline bool TypeCast::_internal_has_type_name() const { return this != internal_default_instance() && _impl_.type_name_ != nullptr; } inline bool TypeCast::has_type_name() const { return _internal_has_type_name(); } inline void TypeCast::clear_type_name() { if (GetArenaForAllocation() == nullptr && _impl_.type_name_ != nullptr) { delete _impl_.type_name_; } _impl_.type_name_ = nullptr; } inline const ::pg_query::TypeName& TypeCast::_internal_type_name() const { const ::pg_query::TypeName* p = _impl_.type_name_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_TypeName_default_instance_); } inline const ::pg_query::TypeName& TypeCast::type_name() const { // @@protoc_insertion_point(field_get:pg_query.TypeCast.type_name) return _internal_type_name(); } inline void TypeCast::unsafe_arena_set_allocated_type_name( ::pg_query::TypeName* type_name) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.type_name_); } _impl_.type_name_ = type_name; if (type_name) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.TypeCast.type_name) } inline ::pg_query::TypeName* TypeCast::release_type_name() { ::pg_query::TypeName* temp = _impl_.type_name_; _impl_.type_name_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::TypeName* TypeCast::unsafe_arena_release_type_name() { // @@protoc_insertion_point(field_release:pg_query.TypeCast.type_name) ::pg_query::TypeName* temp = _impl_.type_name_; _impl_.type_name_ = nullptr; return temp; } inline ::pg_query::TypeName* TypeCast::_internal_mutable_type_name() { if (_impl_.type_name_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArenaForAllocation()); _impl_.type_name_ = p; } return _impl_.type_name_; } inline ::pg_query::TypeName* TypeCast::mutable_type_name() { ::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* type_name) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.type_name_; } if (type_name) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(type_name); if (message_arena != submessage_arena) { type_name = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, type_name, submessage_arena); } } else { } _impl_.type_name_ = type_name; // @@protoc_insertion_point(field_set_allocated:pg_query.TypeCast.type_name) } // int32 location = 3 [json_name = "location"]; inline void TypeCast::clear_location() { _impl_.location_ = 0; } inline int32_t TypeCast::_internal_location() const { return _impl_.location_; } inline int32_t TypeCast::location() const { // @@protoc_insertion_point(field_get:pg_query.TypeCast.location) return _internal_location(); } inline void TypeCast::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void TypeCast::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.TypeCast.location) } // ------------------------------------------------------------------- // CollateClause // .pg_query.Node arg = 1 [json_name = "arg"]; inline bool CollateClause::_internal_has_arg() const { return this != internal_default_instance() && _impl_.arg_ != nullptr; } inline bool CollateClause::has_arg() const { return _internal_has_arg(); } inline void CollateClause::clear_arg() { if (GetArenaForAllocation() == nullptr && _impl_.arg_ != nullptr) { delete _impl_.arg_; } _impl_.arg_ = nullptr; } inline const ::pg_query::Node& CollateClause::_internal_arg() const { const ::pg_query::Node* p = _impl_.arg_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& CollateClause::arg() const { // @@protoc_insertion_point(field_get:pg_query.CollateClause.arg) return _internal_arg(); } inline void CollateClause::unsafe_arena_set_allocated_arg( ::pg_query::Node* arg) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.arg_); } _impl_.arg_ = arg; if (arg) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CollateClause.arg) } inline ::pg_query::Node* CollateClause::release_arg() { ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* CollateClause::unsafe_arena_release_arg() { // @@protoc_insertion_point(field_release:pg_query.CollateClause.arg) ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; return temp; } inline ::pg_query::Node* CollateClause::_internal_mutable_arg() { if (_impl_.arg_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.arg_ = p; } return _impl_.arg_; } inline ::pg_query::Node* CollateClause::mutable_arg() { ::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* arg) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.arg_; } if (arg) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(arg); if (message_arena != submessage_arena) { arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, arg, submessage_arena); } } else { } _impl_.arg_ = arg; // @@protoc_insertion_point(field_set_allocated:pg_query.CollateClause.arg) } // repeated .pg_query.Node collname = 2 [json_name = "collname"]; inline int CollateClause::_internal_collname_size() const { return _impl_.collname_.size(); } inline int CollateClause::collname_size() const { return _internal_collname_size(); } inline void CollateClause::clear_collname() { _impl_.collname_.Clear(); } inline ::pg_query::Node* CollateClause::mutable_collname(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CollateClause.collname) return _impl_.collname_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CollateClause::mutable_collname() { // @@protoc_insertion_point(field_mutable_list:pg_query.CollateClause.collname) return &_impl_.collname_; } inline const ::pg_query::Node& CollateClause::_internal_collname(int index) const { return _impl_.collname_.Get(index); } inline const ::pg_query::Node& CollateClause::collname(int index) const { // @@protoc_insertion_point(field_get:pg_query.CollateClause.collname) return _internal_collname(index); } inline ::pg_query::Node* CollateClause::_internal_add_collname() { return _impl_.collname_.Add(); } inline ::pg_query::Node* CollateClause::add_collname() { ::pg_query::Node* _add = _internal_add_collname(); // @@protoc_insertion_point(field_add:pg_query.CollateClause.collname) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CollateClause::collname() const { // @@protoc_insertion_point(field_list:pg_query.CollateClause.collname) return _impl_.collname_; } // int32 location = 3 [json_name = "location"]; inline void CollateClause::clear_location() { _impl_.location_ = 0; } inline int32_t CollateClause::_internal_location() const { return _impl_.location_; } inline int32_t CollateClause::location() const { // @@protoc_insertion_point(field_get:pg_query.CollateClause.location) return _internal_location(); } inline void CollateClause::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void CollateClause::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.CollateClause.location) } // ------------------------------------------------------------------- // SortBy // .pg_query.Node node = 1 [json_name = "node"]; inline bool SortBy::_internal_has_node() const { return this != internal_default_instance() && _impl_.node_ != nullptr; } inline bool SortBy::has_node() const { return _internal_has_node(); } inline void SortBy::clear_node() { if (GetArenaForAllocation() == nullptr && _impl_.node_ != nullptr) { delete _impl_.node_; } _impl_.node_ = nullptr; } inline const ::pg_query::Node& SortBy::_internal_node() const { const ::pg_query::Node* p = _impl_.node_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& SortBy::node() const { // @@protoc_insertion_point(field_get:pg_query.SortBy.node) return _internal_node(); } inline void SortBy::unsafe_arena_set_allocated_node( ::pg_query::Node* node) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.node_); } _impl_.node_ = node; if (node) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.SortBy.node) } inline ::pg_query::Node* SortBy::release_node() { ::pg_query::Node* temp = _impl_.node_; _impl_.node_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* SortBy::unsafe_arena_release_node() { // @@protoc_insertion_point(field_release:pg_query.SortBy.node) ::pg_query::Node* temp = _impl_.node_; _impl_.node_ = nullptr; return temp; } inline ::pg_query::Node* SortBy::_internal_mutable_node() { if (_impl_.node_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.node_ = p; } return _impl_.node_; } inline ::pg_query::Node* SortBy::mutable_node() { ::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* node) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.node_; } if (node) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(node); if (message_arena != submessage_arena) { node = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, node, submessage_arena); } } else { } _impl_.node_ = node; // @@protoc_insertion_point(field_set_allocated:pg_query.SortBy.node) } // .pg_query.SortByDir sortby_dir = 2 [json_name = "sortby_dir"]; inline void SortBy::clear_sortby_dir() { _impl_.sortby_dir_ = 0; } inline ::pg_query::SortByDir SortBy::_internal_sortby_dir() const { return static_cast< ::pg_query::SortByDir >(_impl_.sortby_dir_); } inline ::pg_query::SortByDir SortBy::sortby_dir() const { // @@protoc_insertion_point(field_get:pg_query.SortBy.sortby_dir) return _internal_sortby_dir(); } inline void SortBy::_internal_set_sortby_dir(::pg_query::SortByDir value) { _impl_.sortby_dir_ = value; } inline void SortBy::set_sortby_dir(::pg_query::SortByDir value) { _internal_set_sortby_dir(value); // @@protoc_insertion_point(field_set:pg_query.SortBy.sortby_dir) } // .pg_query.SortByNulls sortby_nulls = 3 [json_name = "sortby_nulls"]; inline void SortBy::clear_sortby_nulls() { _impl_.sortby_nulls_ = 0; } inline ::pg_query::SortByNulls SortBy::_internal_sortby_nulls() const { return static_cast< ::pg_query::SortByNulls >(_impl_.sortby_nulls_); } inline ::pg_query::SortByNulls SortBy::sortby_nulls() const { // @@protoc_insertion_point(field_get:pg_query.SortBy.sortby_nulls) return _internal_sortby_nulls(); } inline void SortBy::_internal_set_sortby_nulls(::pg_query::SortByNulls value) { _impl_.sortby_nulls_ = value; } inline void SortBy::set_sortby_nulls(::pg_query::SortByNulls value) { _internal_set_sortby_nulls(value); // @@protoc_insertion_point(field_set:pg_query.SortBy.sortby_nulls) } // repeated .pg_query.Node use_op = 4 [json_name = "useOp"]; inline int SortBy::_internal_use_op_size() const { return _impl_.use_op_.size(); } inline int SortBy::use_op_size() const { return _internal_use_op_size(); } inline void SortBy::clear_use_op() { _impl_.use_op_.Clear(); } inline ::pg_query::Node* SortBy::mutable_use_op(int index) { // @@protoc_insertion_point(field_mutable:pg_query.SortBy.use_op) return _impl_.use_op_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* SortBy::mutable_use_op() { // @@protoc_insertion_point(field_mutable_list:pg_query.SortBy.use_op) return &_impl_.use_op_; } inline const ::pg_query::Node& SortBy::_internal_use_op(int index) const { return _impl_.use_op_.Get(index); } inline const ::pg_query::Node& SortBy::use_op(int index) const { // @@protoc_insertion_point(field_get:pg_query.SortBy.use_op) return _internal_use_op(index); } inline ::pg_query::Node* SortBy::_internal_add_use_op() { return _impl_.use_op_.Add(); } inline ::pg_query::Node* SortBy::add_use_op() { ::pg_query::Node* _add = _internal_add_use_op(); // @@protoc_insertion_point(field_add:pg_query.SortBy.use_op) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& SortBy::use_op() const { // @@protoc_insertion_point(field_list:pg_query.SortBy.use_op) return _impl_.use_op_; } // int32 location = 5 [json_name = "location"]; inline void SortBy::clear_location() { _impl_.location_ = 0; } inline int32_t SortBy::_internal_location() const { return _impl_.location_; } inline int32_t SortBy::location() const { // @@protoc_insertion_point(field_get:pg_query.SortBy.location) return _internal_location(); } inline void SortBy::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void SortBy::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.SortBy.location) } // ------------------------------------------------------------------- // WindowDef // string name = 1 [json_name = "name"]; inline void WindowDef::clear_name() { _impl_.name_.ClearToEmpty(); } inline const std::string& WindowDef::name() const { // @@protoc_insertion_point(field_get:pg_query.WindowDef.name) return _internal_name(); } template inline PROTOBUF_ALWAYS_INLINE void WindowDef::set_name(ArgT0&& arg0, ArgT... args) { _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.WindowDef.name) } inline std::string* WindowDef::mutable_name() { 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 { return _impl_.name_.Get(); } inline void WindowDef::_internal_set_name(const std::string& value) { _impl_.name_.Set(value, GetArenaForAllocation()); } inline std::string* WindowDef::_internal_mutable_name() { return _impl_.name_.Mutable(GetArenaForAllocation()); } inline std::string* WindowDef::release_name() { // @@protoc_insertion_point(field_release:pg_query.WindowDef.name) return _impl_.name_.Release(); } inline void WindowDef::set_allocated_name(std::string* name) { if (name != nullptr) { } else { } _impl_.name_.SetAllocated(name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.name_.IsDefault()) { _impl_.name_.Set("", GetArenaForAllocation()); } #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() { _impl_.refname_.ClearToEmpty(); } inline const std::string& WindowDef::refname() const { // @@protoc_insertion_point(field_get:pg_query.WindowDef.refname) return _internal_refname(); } template inline PROTOBUF_ALWAYS_INLINE void WindowDef::set_refname(ArgT0&& arg0, ArgT... args) { _impl_.refname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.WindowDef.refname) } inline std::string* WindowDef::mutable_refname() { 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 { return _impl_.refname_.Get(); } inline void WindowDef::_internal_set_refname(const std::string& value) { _impl_.refname_.Set(value, GetArenaForAllocation()); } inline std::string* WindowDef::_internal_mutable_refname() { return _impl_.refname_.Mutable(GetArenaForAllocation()); } inline std::string* WindowDef::release_refname() { // @@protoc_insertion_point(field_release:pg_query.WindowDef.refname) return _impl_.refname_.Release(); } inline void WindowDef::set_allocated_refname(std::string* refname) { if (refname != nullptr) { } else { } _impl_.refname_.SetAllocated(refname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.refname_.IsDefault()) { _impl_.refname_.Set("", GetArenaForAllocation()); } #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 _impl_.partition_clause_.size(); } inline int WindowDef::partition_clause_size() const { return _internal_partition_clause_size(); } inline void WindowDef::clear_partition_clause() { _impl_.partition_clause_.Clear(); } inline ::pg_query::Node* WindowDef::mutable_partition_clause(int index) { // @@protoc_insertion_point(field_mutable:pg_query.WindowDef.partition_clause) return _impl_.partition_clause_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* WindowDef::mutable_partition_clause() { // @@protoc_insertion_point(field_mutable_list:pg_query.WindowDef.partition_clause) return &_impl_.partition_clause_; } inline const ::pg_query::Node& WindowDef::_internal_partition_clause(int index) const { return _impl_.partition_clause_.Get(index); } inline const ::pg_query::Node& WindowDef::partition_clause(int index) const { // @@protoc_insertion_point(field_get:pg_query.WindowDef.partition_clause) return _internal_partition_clause(index); } inline ::pg_query::Node* WindowDef::_internal_add_partition_clause() { return _impl_.partition_clause_.Add(); } inline ::pg_query::Node* WindowDef::add_partition_clause() { ::pg_query::Node* _add = _internal_add_partition_clause(); // @@protoc_insertion_point(field_add:pg_query.WindowDef.partition_clause) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& WindowDef::partition_clause() const { // @@protoc_insertion_point(field_list:pg_query.WindowDef.partition_clause) return _impl_.partition_clause_; } // repeated .pg_query.Node order_clause = 4 [json_name = "orderClause"]; inline int WindowDef::_internal_order_clause_size() const { return _impl_.order_clause_.size(); } inline int WindowDef::order_clause_size() const { return _internal_order_clause_size(); } inline void WindowDef::clear_order_clause() { _impl_.order_clause_.Clear(); } inline ::pg_query::Node* WindowDef::mutable_order_clause(int index) { // @@protoc_insertion_point(field_mutable:pg_query.WindowDef.order_clause) return _impl_.order_clause_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* WindowDef::mutable_order_clause() { // @@protoc_insertion_point(field_mutable_list:pg_query.WindowDef.order_clause) return &_impl_.order_clause_; } inline const ::pg_query::Node& WindowDef::_internal_order_clause(int index) const { return _impl_.order_clause_.Get(index); } inline const ::pg_query::Node& WindowDef::order_clause(int index) const { // @@protoc_insertion_point(field_get:pg_query.WindowDef.order_clause) return _internal_order_clause(index); } inline ::pg_query::Node* WindowDef::_internal_add_order_clause() { return _impl_.order_clause_.Add(); } inline ::pg_query::Node* WindowDef::add_order_clause() { ::pg_query::Node* _add = _internal_add_order_clause(); // @@protoc_insertion_point(field_add:pg_query.WindowDef.order_clause) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& WindowDef::order_clause() const { // @@protoc_insertion_point(field_list:pg_query.WindowDef.order_clause) return _impl_.order_clause_; } // int32 frame_options = 5 [json_name = "frameOptions"]; inline void WindowDef::clear_frame_options() { _impl_.frame_options_ = 0; } inline int32_t WindowDef::_internal_frame_options() const { return _impl_.frame_options_; } inline int32_t WindowDef::frame_options() const { // @@protoc_insertion_point(field_get:pg_query.WindowDef.frame_options) return _internal_frame_options(); } inline void WindowDef::_internal_set_frame_options(int32_t value) { _impl_.frame_options_ = value; } inline void WindowDef::set_frame_options(int32_t value) { _internal_set_frame_options(value); // @@protoc_insertion_point(field_set:pg_query.WindowDef.frame_options) } // .pg_query.Node start_offset = 6 [json_name = "startOffset"]; inline bool WindowDef::_internal_has_start_offset() const { return this != internal_default_instance() && _impl_.start_offset_ != nullptr; } inline bool WindowDef::has_start_offset() const { return _internal_has_start_offset(); } inline void WindowDef::clear_start_offset() { if (GetArenaForAllocation() == nullptr && _impl_.start_offset_ != nullptr) { delete _impl_.start_offset_; } _impl_.start_offset_ = nullptr; } inline const ::pg_query::Node& WindowDef::_internal_start_offset() const { const ::pg_query::Node* p = _impl_.start_offset_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& WindowDef::start_offset() const { // @@protoc_insertion_point(field_get:pg_query.WindowDef.start_offset) return _internal_start_offset(); } inline void WindowDef::unsafe_arena_set_allocated_start_offset( ::pg_query::Node* start_offset) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.start_offset_); } _impl_.start_offset_ = start_offset; if (start_offset) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.WindowDef.start_offset) } inline ::pg_query::Node* WindowDef::release_start_offset() { ::pg_query::Node* temp = _impl_.start_offset_; _impl_.start_offset_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* WindowDef::unsafe_arena_release_start_offset() { // @@protoc_insertion_point(field_release:pg_query.WindowDef.start_offset) ::pg_query::Node* temp = _impl_.start_offset_; _impl_.start_offset_ = nullptr; return temp; } inline ::pg_query::Node* WindowDef::_internal_mutable_start_offset() { if (_impl_.start_offset_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.start_offset_ = p; } return _impl_.start_offset_; } inline ::pg_query::Node* WindowDef::mutable_start_offset() { ::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* start_offset) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.start_offset_; } if (start_offset) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(start_offset); if (message_arena != submessage_arena) { start_offset = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, start_offset, submessage_arena); } } else { } _impl_.start_offset_ = start_offset; // @@protoc_insertion_point(field_set_allocated:pg_query.WindowDef.start_offset) } // .pg_query.Node end_offset = 7 [json_name = "endOffset"]; inline bool WindowDef::_internal_has_end_offset() const { return this != internal_default_instance() && _impl_.end_offset_ != nullptr; } inline bool WindowDef::has_end_offset() const { return _internal_has_end_offset(); } inline void WindowDef::clear_end_offset() { if (GetArenaForAllocation() == nullptr && _impl_.end_offset_ != nullptr) { delete _impl_.end_offset_; } _impl_.end_offset_ = nullptr; } inline const ::pg_query::Node& WindowDef::_internal_end_offset() const { const ::pg_query::Node* p = _impl_.end_offset_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& WindowDef::end_offset() const { // @@protoc_insertion_point(field_get:pg_query.WindowDef.end_offset) return _internal_end_offset(); } inline void WindowDef::unsafe_arena_set_allocated_end_offset( ::pg_query::Node* end_offset) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.end_offset_); } _impl_.end_offset_ = end_offset; if (end_offset) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.WindowDef.end_offset) } inline ::pg_query::Node* WindowDef::release_end_offset() { ::pg_query::Node* temp = _impl_.end_offset_; _impl_.end_offset_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* WindowDef::unsafe_arena_release_end_offset() { // @@protoc_insertion_point(field_release:pg_query.WindowDef.end_offset) ::pg_query::Node* temp = _impl_.end_offset_; _impl_.end_offset_ = nullptr; return temp; } inline ::pg_query::Node* WindowDef::_internal_mutable_end_offset() { if (_impl_.end_offset_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.end_offset_ = p; } return _impl_.end_offset_; } inline ::pg_query::Node* WindowDef::mutable_end_offset() { ::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* end_offset) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.end_offset_; } if (end_offset) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(end_offset); if (message_arena != submessage_arena) { end_offset = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, end_offset, submessage_arena); } } else { } _impl_.end_offset_ = end_offset; // @@protoc_insertion_point(field_set_allocated:pg_query.WindowDef.end_offset) } // int32 location = 8 [json_name = "location"]; inline void WindowDef::clear_location() { _impl_.location_ = 0; } inline int32_t WindowDef::_internal_location() const { return _impl_.location_; } inline int32_t WindowDef::location() const { // @@protoc_insertion_point(field_get:pg_query.WindowDef.location) return _internal_location(); } inline void WindowDef::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void WindowDef::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.WindowDef.location) } // ------------------------------------------------------------------- // RangeSubselect // bool lateral = 1 [json_name = "lateral"]; inline void RangeSubselect::clear_lateral() { _impl_.lateral_ = false; } inline bool RangeSubselect::_internal_lateral() const { return _impl_.lateral_; } inline bool RangeSubselect::lateral() const { // @@protoc_insertion_point(field_get:pg_query.RangeSubselect.lateral) return _internal_lateral(); } inline void RangeSubselect::_internal_set_lateral(bool value) { _impl_.lateral_ = value; } inline void RangeSubselect::set_lateral(bool value) { _internal_set_lateral(value); // @@protoc_insertion_point(field_set:pg_query.RangeSubselect.lateral) } // .pg_query.Node subquery = 2 [json_name = "subquery"]; inline bool RangeSubselect::_internal_has_subquery() const { return this != internal_default_instance() && _impl_.subquery_ != nullptr; } inline bool RangeSubselect::has_subquery() const { return _internal_has_subquery(); } inline void RangeSubselect::clear_subquery() { if (GetArenaForAllocation() == nullptr && _impl_.subquery_ != nullptr) { delete _impl_.subquery_; } _impl_.subquery_ = nullptr; } inline const ::pg_query::Node& RangeSubselect::_internal_subquery() const { const ::pg_query::Node* p = _impl_.subquery_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& RangeSubselect::subquery() const { // @@protoc_insertion_point(field_get:pg_query.RangeSubselect.subquery) return _internal_subquery(); } inline void RangeSubselect::unsafe_arena_set_allocated_subquery( ::pg_query::Node* subquery) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.subquery_); } _impl_.subquery_ = subquery; if (subquery) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeSubselect.subquery) } inline ::pg_query::Node* RangeSubselect::release_subquery() { ::pg_query::Node* temp = _impl_.subquery_; _impl_.subquery_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* RangeSubselect::unsafe_arena_release_subquery() { // @@protoc_insertion_point(field_release:pg_query.RangeSubselect.subquery) ::pg_query::Node* temp = _impl_.subquery_; _impl_.subquery_ = nullptr; return temp; } inline ::pg_query::Node* RangeSubselect::_internal_mutable_subquery() { if (_impl_.subquery_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.subquery_ = p; } return _impl_.subquery_; } inline ::pg_query::Node* RangeSubselect::mutable_subquery() { ::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* subquery) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.subquery_; } if (subquery) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(subquery); if (message_arena != submessage_arena) { subquery = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, subquery, submessage_arena); } } else { } _impl_.subquery_ = subquery; // @@protoc_insertion_point(field_set_allocated:pg_query.RangeSubselect.subquery) } // .pg_query.Alias alias = 3 [json_name = "alias"]; inline bool RangeSubselect::_internal_has_alias() const { return this != internal_default_instance() && _impl_.alias_ != nullptr; } inline bool RangeSubselect::has_alias() const { return _internal_has_alias(); } inline void RangeSubselect::clear_alias() { if (GetArenaForAllocation() == nullptr && _impl_.alias_ != nullptr) { delete _impl_.alias_; } _impl_.alias_ = nullptr; } inline const ::pg_query::Alias& RangeSubselect::_internal_alias() const { const ::pg_query::Alias* p = _impl_.alias_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Alias_default_instance_); } inline const ::pg_query::Alias& RangeSubselect::alias() const { // @@protoc_insertion_point(field_get:pg_query.RangeSubselect.alias) return _internal_alias(); } inline void RangeSubselect::unsafe_arena_set_allocated_alias( ::pg_query::Alias* alias) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.alias_); } _impl_.alias_ = alias; if (alias) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeSubselect.alias) } inline ::pg_query::Alias* RangeSubselect::release_alias() { ::pg_query::Alias* temp = _impl_.alias_; _impl_.alias_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Alias* RangeSubselect::unsafe_arena_release_alias() { // @@protoc_insertion_point(field_release:pg_query.RangeSubselect.alias) ::pg_query::Alias* temp = _impl_.alias_; _impl_.alias_ = nullptr; return temp; } inline ::pg_query::Alias* RangeSubselect::_internal_mutable_alias() { if (_impl_.alias_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Alias>(GetArenaForAllocation()); _impl_.alias_ = p; } return _impl_.alias_; } inline ::pg_query::Alias* RangeSubselect::mutable_alias() { ::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* alias) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.alias_; } if (alias) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(alias); if (message_arena != submessage_arena) { alias = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, alias, submessage_arena); } } else { } _impl_.alias_ = alias; // @@protoc_insertion_point(field_set_allocated:pg_query.RangeSubselect.alias) } // ------------------------------------------------------------------- // RangeFunction // bool lateral = 1 [json_name = "lateral"]; inline void RangeFunction::clear_lateral() { _impl_.lateral_ = false; } inline bool RangeFunction::_internal_lateral() const { return _impl_.lateral_; } inline bool RangeFunction::lateral() const { // @@protoc_insertion_point(field_get:pg_query.RangeFunction.lateral) return _internal_lateral(); } inline void RangeFunction::_internal_set_lateral(bool value) { _impl_.lateral_ = value; } inline void RangeFunction::set_lateral(bool value) { _internal_set_lateral(value); // @@protoc_insertion_point(field_set:pg_query.RangeFunction.lateral) } // bool ordinality = 2 [json_name = "ordinality"]; inline void RangeFunction::clear_ordinality() { _impl_.ordinality_ = false; } inline bool RangeFunction::_internal_ordinality() const { return _impl_.ordinality_; } inline bool RangeFunction::ordinality() const { // @@protoc_insertion_point(field_get:pg_query.RangeFunction.ordinality) return _internal_ordinality(); } inline void RangeFunction::_internal_set_ordinality(bool value) { _impl_.ordinality_ = value; } inline void RangeFunction::set_ordinality(bool value) { _internal_set_ordinality(value); // @@protoc_insertion_point(field_set:pg_query.RangeFunction.ordinality) } // bool is_rowsfrom = 3 [json_name = "is_rowsfrom"]; inline void RangeFunction::clear_is_rowsfrom() { _impl_.is_rowsfrom_ = false; } inline bool RangeFunction::_internal_is_rowsfrom() const { return _impl_.is_rowsfrom_; } inline bool RangeFunction::is_rowsfrom() const { // @@protoc_insertion_point(field_get:pg_query.RangeFunction.is_rowsfrom) return _internal_is_rowsfrom(); } inline void RangeFunction::_internal_set_is_rowsfrom(bool value) { _impl_.is_rowsfrom_ = value; } inline void RangeFunction::set_is_rowsfrom(bool value) { _internal_set_is_rowsfrom(value); // @@protoc_insertion_point(field_set:pg_query.RangeFunction.is_rowsfrom) } // repeated .pg_query.Node functions = 4 [json_name = "functions"]; inline int RangeFunction::_internal_functions_size() const { return _impl_.functions_.size(); } inline int RangeFunction::functions_size() const { return _internal_functions_size(); } inline void RangeFunction::clear_functions() { _impl_.functions_.Clear(); } inline ::pg_query::Node* RangeFunction::mutable_functions(int index) { // @@protoc_insertion_point(field_mutable:pg_query.RangeFunction.functions) return _impl_.functions_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* RangeFunction::mutable_functions() { // @@protoc_insertion_point(field_mutable_list:pg_query.RangeFunction.functions) return &_impl_.functions_; } inline const ::pg_query::Node& RangeFunction::_internal_functions(int index) const { return _impl_.functions_.Get(index); } inline const ::pg_query::Node& RangeFunction::functions(int index) const { // @@protoc_insertion_point(field_get:pg_query.RangeFunction.functions) return _internal_functions(index); } inline ::pg_query::Node* RangeFunction::_internal_add_functions() { return _impl_.functions_.Add(); } inline ::pg_query::Node* RangeFunction::add_functions() { ::pg_query::Node* _add = _internal_add_functions(); // @@protoc_insertion_point(field_add:pg_query.RangeFunction.functions) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& RangeFunction::functions() const { // @@protoc_insertion_point(field_list:pg_query.RangeFunction.functions) return _impl_.functions_; } // .pg_query.Alias alias = 5 [json_name = "alias"]; inline bool RangeFunction::_internal_has_alias() const { return this != internal_default_instance() && _impl_.alias_ != nullptr; } inline bool RangeFunction::has_alias() const { return _internal_has_alias(); } inline void RangeFunction::clear_alias() { if (GetArenaForAllocation() == nullptr && _impl_.alias_ != nullptr) { delete _impl_.alias_; } _impl_.alias_ = nullptr; } inline const ::pg_query::Alias& RangeFunction::_internal_alias() const { const ::pg_query::Alias* p = _impl_.alias_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Alias_default_instance_); } inline const ::pg_query::Alias& RangeFunction::alias() const { // @@protoc_insertion_point(field_get:pg_query.RangeFunction.alias) return _internal_alias(); } inline void RangeFunction::unsafe_arena_set_allocated_alias( ::pg_query::Alias* alias) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.alias_); } _impl_.alias_ = alias; if (alias) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeFunction.alias) } inline ::pg_query::Alias* RangeFunction::release_alias() { ::pg_query::Alias* temp = _impl_.alias_; _impl_.alias_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Alias* RangeFunction::unsafe_arena_release_alias() { // @@protoc_insertion_point(field_release:pg_query.RangeFunction.alias) ::pg_query::Alias* temp = _impl_.alias_; _impl_.alias_ = nullptr; return temp; } inline ::pg_query::Alias* RangeFunction::_internal_mutable_alias() { if (_impl_.alias_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Alias>(GetArenaForAllocation()); _impl_.alias_ = p; } return _impl_.alias_; } inline ::pg_query::Alias* RangeFunction::mutable_alias() { ::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* alias) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.alias_; } if (alias) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(alias); if (message_arena != submessage_arena) { alias = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, alias, submessage_arena); } } else { } _impl_.alias_ = alias; // @@protoc_insertion_point(field_set_allocated:pg_query.RangeFunction.alias) } // repeated .pg_query.Node coldeflist = 6 [json_name = "coldeflist"]; inline int RangeFunction::_internal_coldeflist_size() const { return _impl_.coldeflist_.size(); } inline int RangeFunction::coldeflist_size() const { return _internal_coldeflist_size(); } inline void RangeFunction::clear_coldeflist() { _impl_.coldeflist_.Clear(); } inline ::pg_query::Node* RangeFunction::mutable_coldeflist(int index) { // @@protoc_insertion_point(field_mutable:pg_query.RangeFunction.coldeflist) return _impl_.coldeflist_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* RangeFunction::mutable_coldeflist() { // @@protoc_insertion_point(field_mutable_list:pg_query.RangeFunction.coldeflist) return &_impl_.coldeflist_; } inline const ::pg_query::Node& RangeFunction::_internal_coldeflist(int index) const { return _impl_.coldeflist_.Get(index); } inline const ::pg_query::Node& RangeFunction::coldeflist(int index) const { // @@protoc_insertion_point(field_get:pg_query.RangeFunction.coldeflist) return _internal_coldeflist(index); } inline ::pg_query::Node* RangeFunction::_internal_add_coldeflist() { return _impl_.coldeflist_.Add(); } inline ::pg_query::Node* RangeFunction::add_coldeflist() { ::pg_query::Node* _add = _internal_add_coldeflist(); // @@protoc_insertion_point(field_add:pg_query.RangeFunction.coldeflist) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& RangeFunction::coldeflist() const { // @@protoc_insertion_point(field_list:pg_query.RangeFunction.coldeflist) return _impl_.coldeflist_; } // ------------------------------------------------------------------- // RangeTableSample // .pg_query.Node relation = 1 [json_name = "relation"]; inline bool RangeTableSample::_internal_has_relation() const { return this != internal_default_instance() && _impl_.relation_ != nullptr; } inline bool RangeTableSample::has_relation() const { return _internal_has_relation(); } inline void RangeTableSample::clear_relation() { if (GetArenaForAllocation() == nullptr && _impl_.relation_ != nullptr) { delete _impl_.relation_; } _impl_.relation_ = nullptr; } inline const ::pg_query::Node& RangeTableSample::_internal_relation() const { const ::pg_query::Node* p = _impl_.relation_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& RangeTableSample::relation() const { // @@protoc_insertion_point(field_get:pg_query.RangeTableSample.relation) return _internal_relation(); } inline void RangeTableSample::unsafe_arena_set_allocated_relation( ::pg_query::Node* relation) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.relation_); } _impl_.relation_ = relation; if (relation) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTableSample.relation) } inline ::pg_query::Node* RangeTableSample::release_relation() { ::pg_query::Node* temp = _impl_.relation_; _impl_.relation_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* RangeTableSample::unsafe_arena_release_relation() { // @@protoc_insertion_point(field_release:pg_query.RangeTableSample.relation) ::pg_query::Node* temp = _impl_.relation_; _impl_.relation_ = nullptr; return temp; } inline ::pg_query::Node* RangeTableSample::_internal_mutable_relation() { if (_impl_.relation_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.relation_ = p; } return _impl_.relation_; } inline ::pg_query::Node* RangeTableSample::mutable_relation() { ::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* relation) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.relation_; } if (relation) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(relation); if (message_arena != submessage_arena) { relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, relation, submessage_arena); } } else { } _impl_.relation_ = relation; // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTableSample.relation) } // repeated .pg_query.Node method = 2 [json_name = "method"]; inline int RangeTableSample::_internal_method_size() const { return _impl_.method_.size(); } inline int RangeTableSample::method_size() const { return _internal_method_size(); } inline void RangeTableSample::clear_method() { _impl_.method_.Clear(); } inline ::pg_query::Node* RangeTableSample::mutable_method(int index) { // @@protoc_insertion_point(field_mutable:pg_query.RangeTableSample.method) return _impl_.method_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* RangeTableSample::mutable_method() { // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTableSample.method) return &_impl_.method_; } inline const ::pg_query::Node& RangeTableSample::_internal_method(int index) const { return _impl_.method_.Get(index); } inline const ::pg_query::Node& RangeTableSample::method(int index) const { // @@protoc_insertion_point(field_get:pg_query.RangeTableSample.method) return _internal_method(index); } inline ::pg_query::Node* RangeTableSample::_internal_add_method() { return _impl_.method_.Add(); } inline ::pg_query::Node* RangeTableSample::add_method() { ::pg_query::Node* _add = _internal_add_method(); // @@protoc_insertion_point(field_add:pg_query.RangeTableSample.method) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& RangeTableSample::method() const { // @@protoc_insertion_point(field_list:pg_query.RangeTableSample.method) return _impl_.method_; } // repeated .pg_query.Node args = 3 [json_name = "args"]; inline int RangeTableSample::_internal_args_size() const { return _impl_.args_.size(); } inline int RangeTableSample::args_size() const { return _internal_args_size(); } inline void RangeTableSample::clear_args() { _impl_.args_.Clear(); } inline ::pg_query::Node* RangeTableSample::mutable_args(int index) { // @@protoc_insertion_point(field_mutable:pg_query.RangeTableSample.args) return _impl_.args_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* RangeTableSample::mutable_args() { // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTableSample.args) return &_impl_.args_; } inline const ::pg_query::Node& RangeTableSample::_internal_args(int index) const { return _impl_.args_.Get(index); } inline const ::pg_query::Node& RangeTableSample::args(int index) const { // @@protoc_insertion_point(field_get:pg_query.RangeTableSample.args) return _internal_args(index); } inline ::pg_query::Node* RangeTableSample::_internal_add_args() { return _impl_.args_.Add(); } inline ::pg_query::Node* RangeTableSample::add_args() { ::pg_query::Node* _add = _internal_add_args(); // @@protoc_insertion_point(field_add:pg_query.RangeTableSample.args) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& RangeTableSample::args() const { // @@protoc_insertion_point(field_list:pg_query.RangeTableSample.args) return _impl_.args_; } // .pg_query.Node repeatable = 4 [json_name = "repeatable"]; inline bool RangeTableSample::_internal_has_repeatable() const { return this != internal_default_instance() && _impl_.repeatable_ != nullptr; } inline bool RangeTableSample::has_repeatable() const { return _internal_has_repeatable(); } inline void RangeTableSample::clear_repeatable() { if (GetArenaForAllocation() == nullptr && _impl_.repeatable_ != nullptr) { delete _impl_.repeatable_; } _impl_.repeatable_ = nullptr; } inline const ::pg_query::Node& RangeTableSample::_internal_repeatable() const { const ::pg_query::Node* p = _impl_.repeatable_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& RangeTableSample::repeatable() const { // @@protoc_insertion_point(field_get:pg_query.RangeTableSample.repeatable) return _internal_repeatable(); } inline void RangeTableSample::unsafe_arena_set_allocated_repeatable( ::pg_query::Node* repeatable) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.repeatable_); } _impl_.repeatable_ = repeatable; if (repeatable) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTableSample.repeatable) } inline ::pg_query::Node* RangeTableSample::release_repeatable() { ::pg_query::Node* temp = _impl_.repeatable_; _impl_.repeatable_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* RangeTableSample::unsafe_arena_release_repeatable() { // @@protoc_insertion_point(field_release:pg_query.RangeTableSample.repeatable) ::pg_query::Node* temp = _impl_.repeatable_; _impl_.repeatable_ = nullptr; return temp; } inline ::pg_query::Node* RangeTableSample::_internal_mutable_repeatable() { if (_impl_.repeatable_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.repeatable_ = p; } return _impl_.repeatable_; } inline ::pg_query::Node* RangeTableSample::mutable_repeatable() { ::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* repeatable) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.repeatable_; } if (repeatable) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(repeatable); if (message_arena != submessage_arena) { repeatable = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, repeatable, submessage_arena); } } else { } _impl_.repeatable_ = repeatable; // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTableSample.repeatable) } // int32 location = 5 [json_name = "location"]; inline void RangeTableSample::clear_location() { _impl_.location_ = 0; } inline int32_t RangeTableSample::_internal_location() const { return _impl_.location_; } inline int32_t RangeTableSample::location() const { // @@protoc_insertion_point(field_get:pg_query.RangeTableSample.location) return _internal_location(); } inline void RangeTableSample::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void RangeTableSample::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.RangeTableSample.location) } // ------------------------------------------------------------------- // RangeTableFunc // bool lateral = 1 [json_name = "lateral"]; inline void RangeTableFunc::clear_lateral() { _impl_.lateral_ = false; } inline bool RangeTableFunc::_internal_lateral() const { return _impl_.lateral_; } inline bool RangeTableFunc::lateral() const { // @@protoc_insertion_point(field_get:pg_query.RangeTableFunc.lateral) return _internal_lateral(); } inline void RangeTableFunc::_internal_set_lateral(bool value) { _impl_.lateral_ = value; } inline void RangeTableFunc::set_lateral(bool value) { _internal_set_lateral(value); // @@protoc_insertion_point(field_set:pg_query.RangeTableFunc.lateral) } // .pg_query.Node docexpr = 2 [json_name = "docexpr"]; inline bool RangeTableFunc::_internal_has_docexpr() const { return this != internal_default_instance() && _impl_.docexpr_ != nullptr; } inline bool RangeTableFunc::has_docexpr() const { return _internal_has_docexpr(); } inline void RangeTableFunc::clear_docexpr() { if (GetArenaForAllocation() == nullptr && _impl_.docexpr_ != nullptr) { delete _impl_.docexpr_; } _impl_.docexpr_ = nullptr; } inline const ::pg_query::Node& RangeTableFunc::_internal_docexpr() const { const ::pg_query::Node* p = _impl_.docexpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& RangeTableFunc::docexpr() const { // @@protoc_insertion_point(field_get:pg_query.RangeTableFunc.docexpr) return _internal_docexpr(); } inline void RangeTableFunc::unsafe_arena_set_allocated_docexpr( ::pg_query::Node* docexpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.docexpr_); } _impl_.docexpr_ = docexpr; if (docexpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTableFunc.docexpr) } inline ::pg_query::Node* RangeTableFunc::release_docexpr() { ::pg_query::Node* temp = _impl_.docexpr_; _impl_.docexpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* RangeTableFunc::unsafe_arena_release_docexpr() { // @@protoc_insertion_point(field_release:pg_query.RangeTableFunc.docexpr) ::pg_query::Node* temp = _impl_.docexpr_; _impl_.docexpr_ = nullptr; return temp; } inline ::pg_query::Node* RangeTableFunc::_internal_mutable_docexpr() { if (_impl_.docexpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.docexpr_ = p; } return _impl_.docexpr_; } inline ::pg_query::Node* RangeTableFunc::mutable_docexpr() { ::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* docexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.docexpr_; } if (docexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(docexpr); if (message_arena != submessage_arena) { docexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, docexpr, submessage_arena); } } else { } _impl_.docexpr_ = docexpr; // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTableFunc.docexpr) } // .pg_query.Node rowexpr = 3 [json_name = "rowexpr"]; inline bool RangeTableFunc::_internal_has_rowexpr() const { return this != internal_default_instance() && _impl_.rowexpr_ != nullptr; } inline bool RangeTableFunc::has_rowexpr() const { return _internal_has_rowexpr(); } inline void RangeTableFunc::clear_rowexpr() { if (GetArenaForAllocation() == nullptr && _impl_.rowexpr_ != nullptr) { delete _impl_.rowexpr_; } _impl_.rowexpr_ = nullptr; } inline const ::pg_query::Node& RangeTableFunc::_internal_rowexpr() const { const ::pg_query::Node* p = _impl_.rowexpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& RangeTableFunc::rowexpr() const { // @@protoc_insertion_point(field_get:pg_query.RangeTableFunc.rowexpr) return _internal_rowexpr(); } inline void RangeTableFunc::unsafe_arena_set_allocated_rowexpr( ::pg_query::Node* rowexpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.rowexpr_); } _impl_.rowexpr_ = rowexpr; if (rowexpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTableFunc.rowexpr) } inline ::pg_query::Node* RangeTableFunc::release_rowexpr() { ::pg_query::Node* temp = _impl_.rowexpr_; _impl_.rowexpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* RangeTableFunc::unsafe_arena_release_rowexpr() { // @@protoc_insertion_point(field_release:pg_query.RangeTableFunc.rowexpr) ::pg_query::Node* temp = _impl_.rowexpr_; _impl_.rowexpr_ = nullptr; return temp; } inline ::pg_query::Node* RangeTableFunc::_internal_mutable_rowexpr() { if (_impl_.rowexpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.rowexpr_ = p; } return _impl_.rowexpr_; } inline ::pg_query::Node* RangeTableFunc::mutable_rowexpr() { ::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* rowexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.rowexpr_; } if (rowexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(rowexpr); if (message_arena != submessage_arena) { rowexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, rowexpr, submessage_arena); } } else { } _impl_.rowexpr_ = rowexpr; // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTableFunc.rowexpr) } // repeated .pg_query.Node namespaces = 4 [json_name = "namespaces"]; inline int RangeTableFunc::_internal_namespaces_size() const { return _impl_.namespaces_.size(); } inline int RangeTableFunc::namespaces_size() const { return _internal_namespaces_size(); } inline void RangeTableFunc::clear_namespaces() { _impl_.namespaces_.Clear(); } inline ::pg_query::Node* RangeTableFunc::mutable_namespaces(int index) { // @@protoc_insertion_point(field_mutable:pg_query.RangeTableFunc.namespaces) return _impl_.namespaces_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* RangeTableFunc::mutable_namespaces() { // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTableFunc.namespaces) return &_impl_.namespaces_; } inline const ::pg_query::Node& RangeTableFunc::_internal_namespaces(int index) const { return _impl_.namespaces_.Get(index); } inline const ::pg_query::Node& RangeTableFunc::namespaces(int index) const { // @@protoc_insertion_point(field_get:pg_query.RangeTableFunc.namespaces) return _internal_namespaces(index); } inline ::pg_query::Node* RangeTableFunc::_internal_add_namespaces() { return _impl_.namespaces_.Add(); } inline ::pg_query::Node* RangeTableFunc::add_namespaces() { ::pg_query::Node* _add = _internal_add_namespaces(); // @@protoc_insertion_point(field_add:pg_query.RangeTableFunc.namespaces) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& RangeTableFunc::namespaces() const { // @@protoc_insertion_point(field_list:pg_query.RangeTableFunc.namespaces) return _impl_.namespaces_; } // repeated .pg_query.Node columns = 5 [json_name = "columns"]; inline int RangeTableFunc::_internal_columns_size() const { return _impl_.columns_.size(); } inline int RangeTableFunc::columns_size() const { return _internal_columns_size(); } inline void RangeTableFunc::clear_columns() { _impl_.columns_.Clear(); } inline ::pg_query::Node* RangeTableFunc::mutable_columns(int index) { // @@protoc_insertion_point(field_mutable:pg_query.RangeTableFunc.columns) return _impl_.columns_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* RangeTableFunc::mutable_columns() { // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTableFunc.columns) return &_impl_.columns_; } inline const ::pg_query::Node& RangeTableFunc::_internal_columns(int index) const { return _impl_.columns_.Get(index); } inline const ::pg_query::Node& RangeTableFunc::columns(int index) const { // @@protoc_insertion_point(field_get:pg_query.RangeTableFunc.columns) return _internal_columns(index); } inline ::pg_query::Node* RangeTableFunc::_internal_add_columns() { return _impl_.columns_.Add(); } inline ::pg_query::Node* RangeTableFunc::add_columns() { ::pg_query::Node* _add = _internal_add_columns(); // @@protoc_insertion_point(field_add:pg_query.RangeTableFunc.columns) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& RangeTableFunc::columns() const { // @@protoc_insertion_point(field_list:pg_query.RangeTableFunc.columns) return _impl_.columns_; } // .pg_query.Alias alias = 6 [json_name = "alias"]; inline bool RangeTableFunc::_internal_has_alias() const { return this != internal_default_instance() && _impl_.alias_ != nullptr; } inline bool RangeTableFunc::has_alias() const { return _internal_has_alias(); } inline void RangeTableFunc::clear_alias() { if (GetArenaForAllocation() == nullptr && _impl_.alias_ != nullptr) { delete _impl_.alias_; } _impl_.alias_ = nullptr; } inline const ::pg_query::Alias& RangeTableFunc::_internal_alias() const { const ::pg_query::Alias* p = _impl_.alias_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Alias_default_instance_); } inline const ::pg_query::Alias& RangeTableFunc::alias() const { // @@protoc_insertion_point(field_get:pg_query.RangeTableFunc.alias) return _internal_alias(); } inline void RangeTableFunc::unsafe_arena_set_allocated_alias( ::pg_query::Alias* alias) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.alias_); } _impl_.alias_ = alias; if (alias) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTableFunc.alias) } inline ::pg_query::Alias* RangeTableFunc::release_alias() { ::pg_query::Alias* temp = _impl_.alias_; _impl_.alias_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Alias* RangeTableFunc::unsafe_arena_release_alias() { // @@protoc_insertion_point(field_release:pg_query.RangeTableFunc.alias) ::pg_query::Alias* temp = _impl_.alias_; _impl_.alias_ = nullptr; return temp; } inline ::pg_query::Alias* RangeTableFunc::_internal_mutable_alias() { if (_impl_.alias_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Alias>(GetArenaForAllocation()); _impl_.alias_ = p; } return _impl_.alias_; } inline ::pg_query::Alias* RangeTableFunc::mutable_alias() { ::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* alias) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.alias_; } if (alias) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(alias); if (message_arena != submessage_arena) { alias = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, alias, submessage_arena); } } else { } _impl_.alias_ = alias; // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTableFunc.alias) } // int32 location = 7 [json_name = "location"]; inline void RangeTableFunc::clear_location() { _impl_.location_ = 0; } inline int32_t RangeTableFunc::_internal_location() const { return _impl_.location_; } inline int32_t RangeTableFunc::location() const { // @@protoc_insertion_point(field_get:pg_query.RangeTableFunc.location) return _internal_location(); } inline void RangeTableFunc::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void RangeTableFunc::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.RangeTableFunc.location) } // ------------------------------------------------------------------- // RangeTableFuncCol // string colname = 1 [json_name = "colname"]; inline void RangeTableFuncCol::clear_colname() { _impl_.colname_.ClearToEmpty(); } inline const std::string& RangeTableFuncCol::colname() const { // @@protoc_insertion_point(field_get:pg_query.RangeTableFuncCol.colname) return _internal_colname(); } template inline PROTOBUF_ALWAYS_INLINE void RangeTableFuncCol::set_colname(ArgT0&& arg0, ArgT... args) { _impl_.colname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.RangeTableFuncCol.colname) } inline std::string* RangeTableFuncCol::mutable_colname() { 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 { return _impl_.colname_.Get(); } inline void RangeTableFuncCol::_internal_set_colname(const std::string& value) { _impl_.colname_.Set(value, GetArenaForAllocation()); } inline std::string* RangeTableFuncCol::_internal_mutable_colname() { return _impl_.colname_.Mutable(GetArenaForAllocation()); } inline std::string* RangeTableFuncCol::release_colname() { // @@protoc_insertion_point(field_release:pg_query.RangeTableFuncCol.colname) return _impl_.colname_.Release(); } inline void RangeTableFuncCol::set_allocated_colname(std::string* colname) { if (colname != nullptr) { } else { } _impl_.colname_.SetAllocated(colname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.colname_.IsDefault()) { _impl_.colname_.Set("", GetArenaForAllocation()); } #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::_internal_has_type_name() const { return this != internal_default_instance() && _impl_.type_name_ != nullptr; } inline bool RangeTableFuncCol::has_type_name() const { return _internal_has_type_name(); } inline void RangeTableFuncCol::clear_type_name() { if (GetArenaForAllocation() == nullptr && _impl_.type_name_ != nullptr) { delete _impl_.type_name_; } _impl_.type_name_ = nullptr; } inline const ::pg_query::TypeName& RangeTableFuncCol::_internal_type_name() const { const ::pg_query::TypeName* p = _impl_.type_name_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_TypeName_default_instance_); } inline const ::pg_query::TypeName& RangeTableFuncCol::type_name() const { // @@protoc_insertion_point(field_get:pg_query.RangeTableFuncCol.type_name) return _internal_type_name(); } inline void RangeTableFuncCol::unsafe_arena_set_allocated_type_name( ::pg_query::TypeName* type_name) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.type_name_); } _impl_.type_name_ = type_name; if (type_name) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTableFuncCol.type_name) } inline ::pg_query::TypeName* RangeTableFuncCol::release_type_name() { ::pg_query::TypeName* temp = _impl_.type_name_; _impl_.type_name_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::TypeName* RangeTableFuncCol::unsafe_arena_release_type_name() { // @@protoc_insertion_point(field_release:pg_query.RangeTableFuncCol.type_name) ::pg_query::TypeName* temp = _impl_.type_name_; _impl_.type_name_ = nullptr; return temp; } inline ::pg_query::TypeName* RangeTableFuncCol::_internal_mutable_type_name() { if (_impl_.type_name_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArenaForAllocation()); _impl_.type_name_ = p; } return _impl_.type_name_; } inline ::pg_query::TypeName* RangeTableFuncCol::mutable_type_name() { ::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* type_name) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.type_name_; } if (type_name) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(type_name); if (message_arena != submessage_arena) { type_name = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, type_name, submessage_arena); } } else { } _impl_.type_name_ = type_name; // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTableFuncCol.type_name) } // bool for_ordinality = 3 [json_name = "for_ordinality"]; inline void RangeTableFuncCol::clear_for_ordinality() { _impl_.for_ordinality_ = false; } inline bool RangeTableFuncCol::_internal_for_ordinality() const { return _impl_.for_ordinality_; } inline bool RangeTableFuncCol::for_ordinality() const { // @@protoc_insertion_point(field_get:pg_query.RangeTableFuncCol.for_ordinality) return _internal_for_ordinality(); } inline void RangeTableFuncCol::_internal_set_for_ordinality(bool value) { _impl_.for_ordinality_ = value; } inline void RangeTableFuncCol::set_for_ordinality(bool value) { _internal_set_for_ordinality(value); // @@protoc_insertion_point(field_set:pg_query.RangeTableFuncCol.for_ordinality) } // bool is_not_null = 4 [json_name = "is_not_null"]; inline void RangeTableFuncCol::clear_is_not_null() { _impl_.is_not_null_ = false; } inline bool RangeTableFuncCol::_internal_is_not_null() const { return _impl_.is_not_null_; } inline bool RangeTableFuncCol::is_not_null() const { // @@protoc_insertion_point(field_get:pg_query.RangeTableFuncCol.is_not_null) return _internal_is_not_null(); } inline void RangeTableFuncCol::_internal_set_is_not_null(bool value) { _impl_.is_not_null_ = value; } inline void RangeTableFuncCol::set_is_not_null(bool value) { _internal_set_is_not_null(value); // @@protoc_insertion_point(field_set:pg_query.RangeTableFuncCol.is_not_null) } // .pg_query.Node colexpr = 5 [json_name = "colexpr"]; inline bool RangeTableFuncCol::_internal_has_colexpr() const { return this != internal_default_instance() && _impl_.colexpr_ != nullptr; } inline bool RangeTableFuncCol::has_colexpr() const { return _internal_has_colexpr(); } inline void RangeTableFuncCol::clear_colexpr() { if (GetArenaForAllocation() == nullptr && _impl_.colexpr_ != nullptr) { delete _impl_.colexpr_; } _impl_.colexpr_ = nullptr; } inline const ::pg_query::Node& RangeTableFuncCol::_internal_colexpr() const { const ::pg_query::Node* p = _impl_.colexpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& RangeTableFuncCol::colexpr() const { // @@protoc_insertion_point(field_get:pg_query.RangeTableFuncCol.colexpr) return _internal_colexpr(); } inline void RangeTableFuncCol::unsafe_arena_set_allocated_colexpr( ::pg_query::Node* colexpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.colexpr_); } _impl_.colexpr_ = colexpr; if (colexpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTableFuncCol.colexpr) } inline ::pg_query::Node* RangeTableFuncCol::release_colexpr() { ::pg_query::Node* temp = _impl_.colexpr_; _impl_.colexpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* RangeTableFuncCol::unsafe_arena_release_colexpr() { // @@protoc_insertion_point(field_release:pg_query.RangeTableFuncCol.colexpr) ::pg_query::Node* temp = _impl_.colexpr_; _impl_.colexpr_ = nullptr; return temp; } inline ::pg_query::Node* RangeTableFuncCol::_internal_mutable_colexpr() { if (_impl_.colexpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.colexpr_ = p; } return _impl_.colexpr_; } inline ::pg_query::Node* RangeTableFuncCol::mutable_colexpr() { ::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* colexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.colexpr_; } if (colexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(colexpr); if (message_arena != submessage_arena) { colexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, colexpr, submessage_arena); } } else { } _impl_.colexpr_ = colexpr; // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTableFuncCol.colexpr) } // .pg_query.Node coldefexpr = 6 [json_name = "coldefexpr"]; inline bool RangeTableFuncCol::_internal_has_coldefexpr() const { return this != internal_default_instance() && _impl_.coldefexpr_ != nullptr; } inline bool RangeTableFuncCol::has_coldefexpr() const { return _internal_has_coldefexpr(); } inline void RangeTableFuncCol::clear_coldefexpr() { if (GetArenaForAllocation() == nullptr && _impl_.coldefexpr_ != nullptr) { delete _impl_.coldefexpr_; } _impl_.coldefexpr_ = nullptr; } inline const ::pg_query::Node& RangeTableFuncCol::_internal_coldefexpr() const { const ::pg_query::Node* p = _impl_.coldefexpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& RangeTableFuncCol::coldefexpr() const { // @@protoc_insertion_point(field_get:pg_query.RangeTableFuncCol.coldefexpr) return _internal_coldefexpr(); } inline void RangeTableFuncCol::unsafe_arena_set_allocated_coldefexpr( ::pg_query::Node* coldefexpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.coldefexpr_); } _impl_.coldefexpr_ = coldefexpr; if (coldefexpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTableFuncCol.coldefexpr) } inline ::pg_query::Node* RangeTableFuncCol::release_coldefexpr() { ::pg_query::Node* temp = _impl_.coldefexpr_; _impl_.coldefexpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* RangeTableFuncCol::unsafe_arena_release_coldefexpr() { // @@protoc_insertion_point(field_release:pg_query.RangeTableFuncCol.coldefexpr) ::pg_query::Node* temp = _impl_.coldefexpr_; _impl_.coldefexpr_ = nullptr; return temp; } inline ::pg_query::Node* RangeTableFuncCol::_internal_mutable_coldefexpr() { if (_impl_.coldefexpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.coldefexpr_ = p; } return _impl_.coldefexpr_; } inline ::pg_query::Node* RangeTableFuncCol::mutable_coldefexpr() { ::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* coldefexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.coldefexpr_; } if (coldefexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(coldefexpr); if (message_arena != submessage_arena) { coldefexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, coldefexpr, submessage_arena); } } else { } _impl_.coldefexpr_ = coldefexpr; // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTableFuncCol.coldefexpr) } // int32 location = 7 [json_name = "location"]; inline void RangeTableFuncCol::clear_location() { _impl_.location_ = 0; } inline int32_t RangeTableFuncCol::_internal_location() const { return _impl_.location_; } inline int32_t RangeTableFuncCol::location() const { // @@protoc_insertion_point(field_get:pg_query.RangeTableFuncCol.location) return _internal_location(); } inline void RangeTableFuncCol::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void RangeTableFuncCol::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.RangeTableFuncCol.location) } // ------------------------------------------------------------------- // TypeName // repeated .pg_query.Node names = 1 [json_name = "names"]; inline int TypeName::_internal_names_size() const { return _impl_.names_.size(); } inline int TypeName::names_size() const { return _internal_names_size(); } inline void TypeName::clear_names() { _impl_.names_.Clear(); } inline ::pg_query::Node* TypeName::mutable_names(int index) { // @@protoc_insertion_point(field_mutable:pg_query.TypeName.names) return _impl_.names_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* TypeName::mutable_names() { // @@protoc_insertion_point(field_mutable_list:pg_query.TypeName.names) return &_impl_.names_; } inline const ::pg_query::Node& TypeName::_internal_names(int index) const { return _impl_.names_.Get(index); } inline const ::pg_query::Node& TypeName::names(int index) const { // @@protoc_insertion_point(field_get:pg_query.TypeName.names) return _internal_names(index); } inline ::pg_query::Node* TypeName::_internal_add_names() { return _impl_.names_.Add(); } inline ::pg_query::Node* TypeName::add_names() { ::pg_query::Node* _add = _internal_add_names(); // @@protoc_insertion_point(field_add:pg_query.TypeName.names) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& TypeName::names() const { // @@protoc_insertion_point(field_list:pg_query.TypeName.names) return _impl_.names_; } // uint32 type_oid = 2 [json_name = "typeOid"]; inline void TypeName::clear_type_oid() { _impl_.type_oid_ = 0u; } inline uint32_t TypeName::_internal_type_oid() const { return _impl_.type_oid_; } inline uint32_t TypeName::type_oid() const { // @@protoc_insertion_point(field_get:pg_query.TypeName.type_oid) return _internal_type_oid(); } inline void TypeName::_internal_set_type_oid(uint32_t value) { _impl_.type_oid_ = value; } inline void TypeName::set_type_oid(uint32_t value) { _internal_set_type_oid(value); // @@protoc_insertion_point(field_set:pg_query.TypeName.type_oid) } // bool setof = 3 [json_name = "setof"]; inline void TypeName::clear_setof() { _impl_.setof_ = false; } inline bool TypeName::_internal_setof() const { return _impl_.setof_; } inline bool TypeName::setof() const { // @@protoc_insertion_point(field_get:pg_query.TypeName.setof) return _internal_setof(); } inline void TypeName::_internal_set_setof(bool value) { _impl_.setof_ = value; } inline void TypeName::set_setof(bool value) { _internal_set_setof(value); // @@protoc_insertion_point(field_set:pg_query.TypeName.setof) } // bool pct_type = 4 [json_name = "pct_type"]; inline void TypeName::clear_pct_type() { _impl_.pct_type_ = false; } inline bool TypeName::_internal_pct_type() const { return _impl_.pct_type_; } inline bool TypeName::pct_type() const { // @@protoc_insertion_point(field_get:pg_query.TypeName.pct_type) return _internal_pct_type(); } inline void TypeName::_internal_set_pct_type(bool value) { _impl_.pct_type_ = value; } inline void TypeName::set_pct_type(bool value) { _internal_set_pct_type(value); // @@protoc_insertion_point(field_set:pg_query.TypeName.pct_type) } // repeated .pg_query.Node typmods = 5 [json_name = "typmods"]; inline int TypeName::_internal_typmods_size() const { return _impl_.typmods_.size(); } inline int TypeName::typmods_size() const { return _internal_typmods_size(); } inline void TypeName::clear_typmods() { _impl_.typmods_.Clear(); } inline ::pg_query::Node* TypeName::mutable_typmods(int index) { // @@protoc_insertion_point(field_mutable:pg_query.TypeName.typmods) return _impl_.typmods_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* TypeName::mutable_typmods() { // @@protoc_insertion_point(field_mutable_list:pg_query.TypeName.typmods) return &_impl_.typmods_; } inline const ::pg_query::Node& TypeName::_internal_typmods(int index) const { return _impl_.typmods_.Get(index); } inline const ::pg_query::Node& TypeName::typmods(int index) const { // @@protoc_insertion_point(field_get:pg_query.TypeName.typmods) return _internal_typmods(index); } inline ::pg_query::Node* TypeName::_internal_add_typmods() { return _impl_.typmods_.Add(); } inline ::pg_query::Node* TypeName::add_typmods() { ::pg_query::Node* _add = _internal_add_typmods(); // @@protoc_insertion_point(field_add:pg_query.TypeName.typmods) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& TypeName::typmods() const { // @@protoc_insertion_point(field_list:pg_query.TypeName.typmods) return _impl_.typmods_; } // int32 typemod = 6 [json_name = "typemod"]; inline void TypeName::clear_typemod() { _impl_.typemod_ = 0; } inline int32_t TypeName::_internal_typemod() const { return _impl_.typemod_; } inline int32_t TypeName::typemod() const { // @@protoc_insertion_point(field_get:pg_query.TypeName.typemod) return _internal_typemod(); } inline void TypeName::_internal_set_typemod(int32_t value) { _impl_.typemod_ = value; } inline void TypeName::set_typemod(int32_t value) { _internal_set_typemod(value); // @@protoc_insertion_point(field_set:pg_query.TypeName.typemod) } // repeated .pg_query.Node array_bounds = 7 [json_name = "arrayBounds"]; inline int TypeName::_internal_array_bounds_size() const { return _impl_.array_bounds_.size(); } inline int TypeName::array_bounds_size() const { return _internal_array_bounds_size(); } inline void TypeName::clear_array_bounds() { _impl_.array_bounds_.Clear(); } inline ::pg_query::Node* TypeName::mutable_array_bounds(int index) { // @@protoc_insertion_point(field_mutable:pg_query.TypeName.array_bounds) return _impl_.array_bounds_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* TypeName::mutable_array_bounds() { // @@protoc_insertion_point(field_mutable_list:pg_query.TypeName.array_bounds) return &_impl_.array_bounds_; } inline const ::pg_query::Node& TypeName::_internal_array_bounds(int index) const { return _impl_.array_bounds_.Get(index); } inline const ::pg_query::Node& TypeName::array_bounds(int index) const { // @@protoc_insertion_point(field_get:pg_query.TypeName.array_bounds) return _internal_array_bounds(index); } inline ::pg_query::Node* TypeName::_internal_add_array_bounds() { return _impl_.array_bounds_.Add(); } inline ::pg_query::Node* TypeName::add_array_bounds() { ::pg_query::Node* _add = _internal_add_array_bounds(); // @@protoc_insertion_point(field_add:pg_query.TypeName.array_bounds) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& TypeName::array_bounds() const { // @@protoc_insertion_point(field_list:pg_query.TypeName.array_bounds) return _impl_.array_bounds_; } // int32 location = 8 [json_name = "location"]; inline void TypeName::clear_location() { _impl_.location_ = 0; } inline int32_t TypeName::_internal_location() const { return _impl_.location_; } inline int32_t TypeName::location() const { // @@protoc_insertion_point(field_get:pg_query.TypeName.location) return _internal_location(); } inline void TypeName::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void TypeName::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.TypeName.location) } // ------------------------------------------------------------------- // ColumnDef // string colname = 1 [json_name = "colname"]; inline void ColumnDef::clear_colname() { _impl_.colname_.ClearToEmpty(); } inline const std::string& ColumnDef::colname() const { // @@protoc_insertion_point(field_get:pg_query.ColumnDef.colname) return _internal_colname(); } template inline PROTOBUF_ALWAYS_INLINE void ColumnDef::set_colname(ArgT0&& arg0, ArgT... args) { _impl_.colname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.ColumnDef.colname) } inline std::string* ColumnDef::mutable_colname() { 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 { return _impl_.colname_.Get(); } inline void ColumnDef::_internal_set_colname(const std::string& value) { _impl_.colname_.Set(value, GetArenaForAllocation()); } inline std::string* ColumnDef::_internal_mutable_colname() { return _impl_.colname_.Mutable(GetArenaForAllocation()); } inline std::string* ColumnDef::release_colname() { // @@protoc_insertion_point(field_release:pg_query.ColumnDef.colname) return _impl_.colname_.Release(); } inline void ColumnDef::set_allocated_colname(std::string* colname) { if (colname != nullptr) { } else { } _impl_.colname_.SetAllocated(colname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.colname_.IsDefault()) { _impl_.colname_.Set("", GetArenaForAllocation()); } #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::_internal_has_type_name() const { return this != internal_default_instance() && _impl_.type_name_ != nullptr; } inline bool ColumnDef::has_type_name() const { return _internal_has_type_name(); } inline void ColumnDef::clear_type_name() { if (GetArenaForAllocation() == nullptr && _impl_.type_name_ != nullptr) { delete _impl_.type_name_; } _impl_.type_name_ = nullptr; } inline const ::pg_query::TypeName& ColumnDef::_internal_type_name() const { const ::pg_query::TypeName* p = _impl_.type_name_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_TypeName_default_instance_); } inline const ::pg_query::TypeName& ColumnDef::type_name() const { // @@protoc_insertion_point(field_get:pg_query.ColumnDef.type_name) return _internal_type_name(); } inline void ColumnDef::unsafe_arena_set_allocated_type_name( ::pg_query::TypeName* type_name) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.type_name_); } _impl_.type_name_ = type_name; if (type_name) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ColumnDef.type_name) } inline ::pg_query::TypeName* ColumnDef::release_type_name() { ::pg_query::TypeName* temp = _impl_.type_name_; _impl_.type_name_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::TypeName* ColumnDef::unsafe_arena_release_type_name() { // @@protoc_insertion_point(field_release:pg_query.ColumnDef.type_name) ::pg_query::TypeName* temp = _impl_.type_name_; _impl_.type_name_ = nullptr; return temp; } inline ::pg_query::TypeName* ColumnDef::_internal_mutable_type_name() { if (_impl_.type_name_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArenaForAllocation()); _impl_.type_name_ = p; } return _impl_.type_name_; } inline ::pg_query::TypeName* ColumnDef::mutable_type_name() { ::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* type_name) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.type_name_; } if (type_name) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(type_name); if (message_arena != submessage_arena) { type_name = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, type_name, submessage_arena); } } else { } _impl_.type_name_ = type_name; // @@protoc_insertion_point(field_set_allocated:pg_query.ColumnDef.type_name) } // string compression = 3 [json_name = "compression"]; inline void ColumnDef::clear_compression() { _impl_.compression_.ClearToEmpty(); } inline const std::string& ColumnDef::compression() const { // @@protoc_insertion_point(field_get:pg_query.ColumnDef.compression) return _internal_compression(); } template inline PROTOBUF_ALWAYS_INLINE void ColumnDef::set_compression(ArgT0&& arg0, ArgT... args) { _impl_.compression_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.ColumnDef.compression) } inline std::string* ColumnDef::mutable_compression() { 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 { return _impl_.compression_.Get(); } inline void ColumnDef::_internal_set_compression(const std::string& value) { _impl_.compression_.Set(value, GetArenaForAllocation()); } inline std::string* ColumnDef::_internal_mutable_compression() { return _impl_.compression_.Mutable(GetArenaForAllocation()); } inline std::string* ColumnDef::release_compression() { // @@protoc_insertion_point(field_release:pg_query.ColumnDef.compression) return _impl_.compression_.Release(); } inline void ColumnDef::set_allocated_compression(std::string* compression) { if (compression != nullptr) { } else { } _impl_.compression_.SetAllocated(compression, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.compression_.IsDefault()) { _impl_.compression_.Set("", GetArenaForAllocation()); } #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() { _impl_.inhcount_ = 0; } inline int32_t ColumnDef::_internal_inhcount() const { return _impl_.inhcount_; } inline int32_t ColumnDef::inhcount() const { // @@protoc_insertion_point(field_get:pg_query.ColumnDef.inhcount) return _internal_inhcount(); } inline void ColumnDef::_internal_set_inhcount(int32_t value) { _impl_.inhcount_ = value; } inline void ColumnDef::set_inhcount(int32_t value) { _internal_set_inhcount(value); // @@protoc_insertion_point(field_set:pg_query.ColumnDef.inhcount) } // bool is_local = 5 [json_name = "is_local"]; inline void ColumnDef::clear_is_local() { _impl_.is_local_ = false; } inline bool ColumnDef::_internal_is_local() const { return _impl_.is_local_; } inline bool ColumnDef::is_local() const { // @@protoc_insertion_point(field_get:pg_query.ColumnDef.is_local) return _internal_is_local(); } inline void ColumnDef::_internal_set_is_local(bool value) { _impl_.is_local_ = value; } inline void ColumnDef::set_is_local(bool value) { _internal_set_is_local(value); // @@protoc_insertion_point(field_set:pg_query.ColumnDef.is_local) } // bool is_not_null = 6 [json_name = "is_not_null"]; inline void ColumnDef::clear_is_not_null() { _impl_.is_not_null_ = false; } inline bool ColumnDef::_internal_is_not_null() const { return _impl_.is_not_null_; } inline bool ColumnDef::is_not_null() const { // @@protoc_insertion_point(field_get:pg_query.ColumnDef.is_not_null) return _internal_is_not_null(); } inline void ColumnDef::_internal_set_is_not_null(bool value) { _impl_.is_not_null_ = value; } inline void ColumnDef::set_is_not_null(bool value) { _internal_set_is_not_null(value); // @@protoc_insertion_point(field_set:pg_query.ColumnDef.is_not_null) } // bool is_from_type = 7 [json_name = "is_from_type"]; inline void ColumnDef::clear_is_from_type() { _impl_.is_from_type_ = false; } inline bool ColumnDef::_internal_is_from_type() const { return _impl_.is_from_type_; } inline bool ColumnDef::is_from_type() const { // @@protoc_insertion_point(field_get:pg_query.ColumnDef.is_from_type) return _internal_is_from_type(); } inline void ColumnDef::_internal_set_is_from_type(bool value) { _impl_.is_from_type_ = value; } inline void ColumnDef::set_is_from_type(bool value) { _internal_set_is_from_type(value); // @@protoc_insertion_point(field_set:pg_query.ColumnDef.is_from_type) } // string storage = 8 [json_name = "storage"]; inline void ColumnDef::clear_storage() { _impl_.storage_.ClearToEmpty(); } inline const std::string& ColumnDef::storage() const { // @@protoc_insertion_point(field_get:pg_query.ColumnDef.storage) return _internal_storage(); } template inline PROTOBUF_ALWAYS_INLINE void ColumnDef::set_storage(ArgT0&& arg0, ArgT... args) { _impl_.storage_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.ColumnDef.storage) } inline std::string* ColumnDef::mutable_storage() { 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 { return _impl_.storage_.Get(); } inline void ColumnDef::_internal_set_storage(const std::string& value) { _impl_.storage_.Set(value, GetArenaForAllocation()); } inline std::string* ColumnDef::_internal_mutable_storage() { return _impl_.storage_.Mutable(GetArenaForAllocation()); } inline std::string* ColumnDef::release_storage() { // @@protoc_insertion_point(field_release:pg_query.ColumnDef.storage) return _impl_.storage_.Release(); } inline void ColumnDef::set_allocated_storage(std::string* storage) { if (storage != nullptr) { } else { } _impl_.storage_.SetAllocated(storage, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.storage_.IsDefault()) { _impl_.storage_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:pg_query.ColumnDef.storage) } // .pg_query.Node raw_default = 9 [json_name = "raw_default"]; inline bool ColumnDef::_internal_has_raw_default() const { return this != internal_default_instance() && _impl_.raw_default_ != nullptr; } inline bool ColumnDef::has_raw_default() const { return _internal_has_raw_default(); } inline void ColumnDef::clear_raw_default() { if (GetArenaForAllocation() == nullptr && _impl_.raw_default_ != nullptr) { delete _impl_.raw_default_; } _impl_.raw_default_ = nullptr; } inline const ::pg_query::Node& ColumnDef::_internal_raw_default() const { const ::pg_query::Node* p = _impl_.raw_default_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& ColumnDef::raw_default() const { // @@protoc_insertion_point(field_get:pg_query.ColumnDef.raw_default) return _internal_raw_default(); } inline void ColumnDef::unsafe_arena_set_allocated_raw_default( ::pg_query::Node* raw_default) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.raw_default_); } _impl_.raw_default_ = raw_default; if (raw_default) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ColumnDef.raw_default) } inline ::pg_query::Node* ColumnDef::release_raw_default() { ::pg_query::Node* temp = _impl_.raw_default_; _impl_.raw_default_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* ColumnDef::unsafe_arena_release_raw_default() { // @@protoc_insertion_point(field_release:pg_query.ColumnDef.raw_default) ::pg_query::Node* temp = _impl_.raw_default_; _impl_.raw_default_ = nullptr; return temp; } inline ::pg_query::Node* ColumnDef::_internal_mutable_raw_default() { if (_impl_.raw_default_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.raw_default_ = p; } return _impl_.raw_default_; } inline ::pg_query::Node* ColumnDef::mutable_raw_default() { ::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* raw_default) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.raw_default_; } if (raw_default) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(raw_default); if (message_arena != submessage_arena) { raw_default = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, raw_default, submessage_arena); } } else { } _impl_.raw_default_ = raw_default; // @@protoc_insertion_point(field_set_allocated:pg_query.ColumnDef.raw_default) } // .pg_query.Node cooked_default = 10 [json_name = "cooked_default"]; inline bool ColumnDef::_internal_has_cooked_default() const { return this != internal_default_instance() && _impl_.cooked_default_ != nullptr; } inline bool ColumnDef::has_cooked_default() const { return _internal_has_cooked_default(); } inline void ColumnDef::clear_cooked_default() { if (GetArenaForAllocation() == nullptr && _impl_.cooked_default_ != nullptr) { delete _impl_.cooked_default_; } _impl_.cooked_default_ = nullptr; } inline const ::pg_query::Node& ColumnDef::_internal_cooked_default() const { const ::pg_query::Node* p = _impl_.cooked_default_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& ColumnDef::cooked_default() const { // @@protoc_insertion_point(field_get:pg_query.ColumnDef.cooked_default) return _internal_cooked_default(); } inline void ColumnDef::unsafe_arena_set_allocated_cooked_default( ::pg_query::Node* cooked_default) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cooked_default_); } _impl_.cooked_default_ = cooked_default; if (cooked_default) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ColumnDef.cooked_default) } inline ::pg_query::Node* ColumnDef::release_cooked_default() { ::pg_query::Node* temp = _impl_.cooked_default_; _impl_.cooked_default_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* ColumnDef::unsafe_arena_release_cooked_default() { // @@protoc_insertion_point(field_release:pg_query.ColumnDef.cooked_default) ::pg_query::Node* temp = _impl_.cooked_default_; _impl_.cooked_default_ = nullptr; return temp; } inline ::pg_query::Node* ColumnDef::_internal_mutable_cooked_default() { if (_impl_.cooked_default_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.cooked_default_ = p; } return _impl_.cooked_default_; } inline ::pg_query::Node* ColumnDef::mutable_cooked_default() { ::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* cooked_default) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.cooked_default_; } if (cooked_default) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(cooked_default); if (message_arena != submessage_arena) { cooked_default = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, cooked_default, submessage_arena); } } else { } _impl_.cooked_default_ = cooked_default; // @@protoc_insertion_point(field_set_allocated:pg_query.ColumnDef.cooked_default) } // string identity = 11 [json_name = "identity"]; inline void ColumnDef::clear_identity() { _impl_.identity_.ClearToEmpty(); } inline const std::string& ColumnDef::identity() const { // @@protoc_insertion_point(field_get:pg_query.ColumnDef.identity) return _internal_identity(); } template inline PROTOBUF_ALWAYS_INLINE void ColumnDef::set_identity(ArgT0&& arg0, ArgT... args) { _impl_.identity_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.ColumnDef.identity) } inline std::string* ColumnDef::mutable_identity() { 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 { return _impl_.identity_.Get(); } inline void ColumnDef::_internal_set_identity(const std::string& value) { _impl_.identity_.Set(value, GetArenaForAllocation()); } inline std::string* ColumnDef::_internal_mutable_identity() { return _impl_.identity_.Mutable(GetArenaForAllocation()); } inline std::string* ColumnDef::release_identity() { // @@protoc_insertion_point(field_release:pg_query.ColumnDef.identity) return _impl_.identity_.Release(); } inline void ColumnDef::set_allocated_identity(std::string* identity) { if (identity != nullptr) { } else { } _impl_.identity_.SetAllocated(identity, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.identity_.IsDefault()) { _impl_.identity_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:pg_query.ColumnDef.identity) } // .pg_query.RangeVar identity_sequence = 12 [json_name = "identitySequence"]; inline bool ColumnDef::_internal_has_identity_sequence() const { return this != internal_default_instance() && _impl_.identity_sequence_ != nullptr; } inline bool ColumnDef::has_identity_sequence() const { return _internal_has_identity_sequence(); } inline void ColumnDef::clear_identity_sequence() { if (GetArenaForAllocation() == nullptr && _impl_.identity_sequence_ != nullptr) { delete _impl_.identity_sequence_; } _impl_.identity_sequence_ = nullptr; } inline const ::pg_query::RangeVar& ColumnDef::_internal_identity_sequence() const { const ::pg_query::RangeVar* p = _impl_.identity_sequence_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& ColumnDef::identity_sequence() const { // @@protoc_insertion_point(field_get:pg_query.ColumnDef.identity_sequence) return _internal_identity_sequence(); } inline void ColumnDef::unsafe_arena_set_allocated_identity_sequence( ::pg_query::RangeVar* identity_sequence) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.identity_sequence_); } _impl_.identity_sequence_ = identity_sequence; if (identity_sequence) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ColumnDef.identity_sequence) } inline ::pg_query::RangeVar* ColumnDef::release_identity_sequence() { ::pg_query::RangeVar* temp = _impl_.identity_sequence_; _impl_.identity_sequence_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* ColumnDef::unsafe_arena_release_identity_sequence() { // @@protoc_insertion_point(field_release:pg_query.ColumnDef.identity_sequence) ::pg_query::RangeVar* temp = _impl_.identity_sequence_; _impl_.identity_sequence_ = nullptr; return temp; } inline ::pg_query::RangeVar* ColumnDef::_internal_mutable_identity_sequence() { if (_impl_.identity_sequence_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.identity_sequence_ = p; } return _impl_.identity_sequence_; } inline ::pg_query::RangeVar* ColumnDef::mutable_identity_sequence() { ::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* identity_sequence) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.identity_sequence_; } if (identity_sequence) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(identity_sequence); if (message_arena != submessage_arena) { identity_sequence = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, identity_sequence, submessage_arena); } } else { } _impl_.identity_sequence_ = identity_sequence; // @@protoc_insertion_point(field_set_allocated:pg_query.ColumnDef.identity_sequence) } // string generated = 13 [json_name = "generated"]; inline void ColumnDef::clear_generated() { _impl_.generated_.ClearToEmpty(); } inline const std::string& ColumnDef::generated() const { // @@protoc_insertion_point(field_get:pg_query.ColumnDef.generated) return _internal_generated(); } template inline PROTOBUF_ALWAYS_INLINE void ColumnDef::set_generated(ArgT0&& arg0, ArgT... args) { _impl_.generated_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.ColumnDef.generated) } inline std::string* ColumnDef::mutable_generated() { 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 { return _impl_.generated_.Get(); } inline void ColumnDef::_internal_set_generated(const std::string& value) { _impl_.generated_.Set(value, GetArenaForAllocation()); } inline std::string* ColumnDef::_internal_mutable_generated() { return _impl_.generated_.Mutable(GetArenaForAllocation()); } inline std::string* ColumnDef::release_generated() { // @@protoc_insertion_point(field_release:pg_query.ColumnDef.generated) return _impl_.generated_.Release(); } inline void ColumnDef::set_allocated_generated(std::string* generated) { if (generated != nullptr) { } else { } _impl_.generated_.SetAllocated(generated, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.generated_.IsDefault()) { _impl_.generated_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:pg_query.ColumnDef.generated) } // .pg_query.CollateClause coll_clause = 14 [json_name = "collClause"]; inline bool ColumnDef::_internal_has_coll_clause() const { return this != internal_default_instance() && _impl_.coll_clause_ != nullptr; } inline bool ColumnDef::has_coll_clause() const { return _internal_has_coll_clause(); } inline void ColumnDef::clear_coll_clause() { if (GetArenaForAllocation() == nullptr && _impl_.coll_clause_ != nullptr) { delete _impl_.coll_clause_; } _impl_.coll_clause_ = nullptr; } inline const ::pg_query::CollateClause& ColumnDef::_internal_coll_clause() const { const ::pg_query::CollateClause* p = _impl_.coll_clause_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_CollateClause_default_instance_); } inline const ::pg_query::CollateClause& ColumnDef::coll_clause() const { // @@protoc_insertion_point(field_get:pg_query.ColumnDef.coll_clause) return _internal_coll_clause(); } inline void ColumnDef::unsafe_arena_set_allocated_coll_clause( ::pg_query::CollateClause* coll_clause) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.coll_clause_); } _impl_.coll_clause_ = coll_clause; if (coll_clause) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.ColumnDef.coll_clause) } inline ::pg_query::CollateClause* ColumnDef::release_coll_clause() { ::pg_query::CollateClause* temp = _impl_.coll_clause_; _impl_.coll_clause_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::CollateClause* ColumnDef::unsafe_arena_release_coll_clause() { // @@protoc_insertion_point(field_release:pg_query.ColumnDef.coll_clause) ::pg_query::CollateClause* temp = _impl_.coll_clause_; _impl_.coll_clause_ = nullptr; return temp; } inline ::pg_query::CollateClause* ColumnDef::_internal_mutable_coll_clause() { if (_impl_.coll_clause_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::CollateClause>(GetArenaForAllocation()); _impl_.coll_clause_ = p; } return _impl_.coll_clause_; } inline ::pg_query::CollateClause* ColumnDef::mutable_coll_clause() { ::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* coll_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.coll_clause_; } if (coll_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(coll_clause); if (message_arena != submessage_arena) { coll_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, coll_clause, submessage_arena); } } else { } _impl_.coll_clause_ = coll_clause; // @@protoc_insertion_point(field_set_allocated:pg_query.ColumnDef.coll_clause) } // uint32 coll_oid = 15 [json_name = "collOid"]; inline void ColumnDef::clear_coll_oid() { _impl_.coll_oid_ = 0u; } inline uint32_t ColumnDef::_internal_coll_oid() const { return _impl_.coll_oid_; } inline uint32_t ColumnDef::coll_oid() const { // @@protoc_insertion_point(field_get:pg_query.ColumnDef.coll_oid) return _internal_coll_oid(); } inline void ColumnDef::_internal_set_coll_oid(uint32_t value) { _impl_.coll_oid_ = value; } inline void ColumnDef::set_coll_oid(uint32_t value) { _internal_set_coll_oid(value); // @@protoc_insertion_point(field_set:pg_query.ColumnDef.coll_oid) } // repeated .pg_query.Node constraints = 16 [json_name = "constraints"]; inline int ColumnDef::_internal_constraints_size() const { return _impl_.constraints_.size(); } inline int ColumnDef::constraints_size() const { return _internal_constraints_size(); } inline void ColumnDef::clear_constraints() { _impl_.constraints_.Clear(); } inline ::pg_query::Node* ColumnDef::mutable_constraints(int index) { // @@protoc_insertion_point(field_mutable:pg_query.ColumnDef.constraints) return _impl_.constraints_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* ColumnDef::mutable_constraints() { // @@protoc_insertion_point(field_mutable_list:pg_query.ColumnDef.constraints) return &_impl_.constraints_; } inline const ::pg_query::Node& ColumnDef::_internal_constraints(int index) const { return _impl_.constraints_.Get(index); } inline const ::pg_query::Node& ColumnDef::constraints(int index) const { // @@protoc_insertion_point(field_get:pg_query.ColumnDef.constraints) return _internal_constraints(index); } inline ::pg_query::Node* ColumnDef::_internal_add_constraints() { return _impl_.constraints_.Add(); } inline ::pg_query::Node* ColumnDef::add_constraints() { ::pg_query::Node* _add = _internal_add_constraints(); // @@protoc_insertion_point(field_add:pg_query.ColumnDef.constraints) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& ColumnDef::constraints() const { // @@protoc_insertion_point(field_list:pg_query.ColumnDef.constraints) return _impl_.constraints_; } // repeated .pg_query.Node fdwoptions = 17 [json_name = "fdwoptions"]; inline int ColumnDef::_internal_fdwoptions_size() const { return _impl_.fdwoptions_.size(); } inline int ColumnDef::fdwoptions_size() const { return _internal_fdwoptions_size(); } inline void ColumnDef::clear_fdwoptions() { _impl_.fdwoptions_.Clear(); } inline ::pg_query::Node* ColumnDef::mutable_fdwoptions(int index) { // @@protoc_insertion_point(field_mutable:pg_query.ColumnDef.fdwoptions) return _impl_.fdwoptions_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* ColumnDef::mutable_fdwoptions() { // @@protoc_insertion_point(field_mutable_list:pg_query.ColumnDef.fdwoptions) return &_impl_.fdwoptions_; } inline const ::pg_query::Node& ColumnDef::_internal_fdwoptions(int index) const { return _impl_.fdwoptions_.Get(index); } inline const ::pg_query::Node& ColumnDef::fdwoptions(int index) const { // @@protoc_insertion_point(field_get:pg_query.ColumnDef.fdwoptions) return _internal_fdwoptions(index); } inline ::pg_query::Node* ColumnDef::_internal_add_fdwoptions() { return _impl_.fdwoptions_.Add(); } inline ::pg_query::Node* ColumnDef::add_fdwoptions() { ::pg_query::Node* _add = _internal_add_fdwoptions(); // @@protoc_insertion_point(field_add:pg_query.ColumnDef.fdwoptions) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& ColumnDef::fdwoptions() const { // @@protoc_insertion_point(field_list:pg_query.ColumnDef.fdwoptions) return _impl_.fdwoptions_; } // int32 location = 18 [json_name = "location"]; inline void ColumnDef::clear_location() { _impl_.location_ = 0; } inline int32_t ColumnDef::_internal_location() const { return _impl_.location_; } inline int32_t ColumnDef::location() const { // @@protoc_insertion_point(field_get:pg_query.ColumnDef.location) return _internal_location(); } inline void ColumnDef::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void ColumnDef::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.ColumnDef.location) } // ------------------------------------------------------------------- // IndexElem // string name = 1 [json_name = "name"]; inline void IndexElem::clear_name() { _impl_.name_.ClearToEmpty(); } inline const std::string& IndexElem::name() const { // @@protoc_insertion_point(field_get:pg_query.IndexElem.name) return _internal_name(); } template inline PROTOBUF_ALWAYS_INLINE void IndexElem::set_name(ArgT0&& arg0, ArgT... args) { _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.IndexElem.name) } inline std::string* IndexElem::mutable_name() { 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 { return _impl_.name_.Get(); } inline void IndexElem::_internal_set_name(const std::string& value) { _impl_.name_.Set(value, GetArenaForAllocation()); } inline std::string* IndexElem::_internal_mutable_name() { return _impl_.name_.Mutable(GetArenaForAllocation()); } inline std::string* IndexElem::release_name() { // @@protoc_insertion_point(field_release:pg_query.IndexElem.name) return _impl_.name_.Release(); } inline void IndexElem::set_allocated_name(std::string* name) { if (name != nullptr) { } else { } _impl_.name_.SetAllocated(name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.name_.IsDefault()) { _impl_.name_.Set("", GetArenaForAllocation()); } #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::_internal_has_expr() const { return this != internal_default_instance() && _impl_.expr_ != nullptr; } inline bool IndexElem::has_expr() const { return _internal_has_expr(); } inline void IndexElem::clear_expr() { if (GetArenaForAllocation() == nullptr && _impl_.expr_ != nullptr) { delete _impl_.expr_; } _impl_.expr_ = nullptr; } inline const ::pg_query::Node& IndexElem::_internal_expr() const { const ::pg_query::Node* p = _impl_.expr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& IndexElem::expr() const { // @@protoc_insertion_point(field_get:pg_query.IndexElem.expr) return _internal_expr(); } inline void IndexElem::unsafe_arena_set_allocated_expr( ::pg_query::Node* expr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.expr_); } _impl_.expr_ = expr; if (expr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.IndexElem.expr) } inline ::pg_query::Node* IndexElem::release_expr() { ::pg_query::Node* temp = _impl_.expr_; _impl_.expr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* IndexElem::unsafe_arena_release_expr() { // @@protoc_insertion_point(field_release:pg_query.IndexElem.expr) ::pg_query::Node* temp = _impl_.expr_; _impl_.expr_ = nullptr; return temp; } inline ::pg_query::Node* IndexElem::_internal_mutable_expr() { if (_impl_.expr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.expr_ = p; } return _impl_.expr_; } inline ::pg_query::Node* IndexElem::mutable_expr() { ::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* expr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.expr_; } if (expr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(expr); if (message_arena != submessage_arena) { expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, expr, submessage_arena); } } else { } _impl_.expr_ = expr; // @@protoc_insertion_point(field_set_allocated:pg_query.IndexElem.expr) } // string indexcolname = 3 [json_name = "indexcolname"]; inline void IndexElem::clear_indexcolname() { _impl_.indexcolname_.ClearToEmpty(); } inline const std::string& IndexElem::indexcolname() const { // @@protoc_insertion_point(field_get:pg_query.IndexElem.indexcolname) return _internal_indexcolname(); } template inline PROTOBUF_ALWAYS_INLINE void IndexElem::set_indexcolname(ArgT0&& arg0, ArgT... args) { _impl_.indexcolname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.IndexElem.indexcolname) } inline std::string* IndexElem::mutable_indexcolname() { 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 { return _impl_.indexcolname_.Get(); } inline void IndexElem::_internal_set_indexcolname(const std::string& value) { _impl_.indexcolname_.Set(value, GetArenaForAllocation()); } inline std::string* IndexElem::_internal_mutable_indexcolname() { return _impl_.indexcolname_.Mutable(GetArenaForAllocation()); } inline std::string* IndexElem::release_indexcolname() { // @@protoc_insertion_point(field_release:pg_query.IndexElem.indexcolname) return _impl_.indexcolname_.Release(); } inline void IndexElem::set_allocated_indexcolname(std::string* indexcolname) { if (indexcolname != nullptr) { } else { } _impl_.indexcolname_.SetAllocated(indexcolname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.indexcolname_.IsDefault()) { _impl_.indexcolname_.Set("", GetArenaForAllocation()); } #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 _impl_.collation_.size(); } inline int IndexElem::collation_size() const { return _internal_collation_size(); } inline void IndexElem::clear_collation() { _impl_.collation_.Clear(); } inline ::pg_query::Node* IndexElem::mutable_collation(int index) { // @@protoc_insertion_point(field_mutable:pg_query.IndexElem.collation) return _impl_.collation_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* IndexElem::mutable_collation() { // @@protoc_insertion_point(field_mutable_list:pg_query.IndexElem.collation) return &_impl_.collation_; } inline const ::pg_query::Node& IndexElem::_internal_collation(int index) const { return _impl_.collation_.Get(index); } inline const ::pg_query::Node& IndexElem::collation(int index) const { // @@protoc_insertion_point(field_get:pg_query.IndexElem.collation) return _internal_collation(index); } inline ::pg_query::Node* IndexElem::_internal_add_collation() { return _impl_.collation_.Add(); } inline ::pg_query::Node* IndexElem::add_collation() { ::pg_query::Node* _add = _internal_add_collation(); // @@protoc_insertion_point(field_add:pg_query.IndexElem.collation) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& IndexElem::collation() const { // @@protoc_insertion_point(field_list:pg_query.IndexElem.collation) return _impl_.collation_; } // repeated .pg_query.Node opclass = 5 [json_name = "opclass"]; inline int IndexElem::_internal_opclass_size() const { return _impl_.opclass_.size(); } inline int IndexElem::opclass_size() const { return _internal_opclass_size(); } inline void IndexElem::clear_opclass() { _impl_.opclass_.Clear(); } inline ::pg_query::Node* IndexElem::mutable_opclass(int index) { // @@protoc_insertion_point(field_mutable:pg_query.IndexElem.opclass) return _impl_.opclass_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* IndexElem::mutable_opclass() { // @@protoc_insertion_point(field_mutable_list:pg_query.IndexElem.opclass) return &_impl_.opclass_; } inline const ::pg_query::Node& IndexElem::_internal_opclass(int index) const { return _impl_.opclass_.Get(index); } inline const ::pg_query::Node& IndexElem::opclass(int index) const { // @@protoc_insertion_point(field_get:pg_query.IndexElem.opclass) return _internal_opclass(index); } inline ::pg_query::Node* IndexElem::_internal_add_opclass() { return _impl_.opclass_.Add(); } inline ::pg_query::Node* IndexElem::add_opclass() { ::pg_query::Node* _add = _internal_add_opclass(); // @@protoc_insertion_point(field_add:pg_query.IndexElem.opclass) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& IndexElem::opclass() const { // @@protoc_insertion_point(field_list:pg_query.IndexElem.opclass) return _impl_.opclass_; } // repeated .pg_query.Node opclassopts = 6 [json_name = "opclassopts"]; inline int IndexElem::_internal_opclassopts_size() const { return _impl_.opclassopts_.size(); } inline int IndexElem::opclassopts_size() const { return _internal_opclassopts_size(); } inline void IndexElem::clear_opclassopts() { _impl_.opclassopts_.Clear(); } inline ::pg_query::Node* IndexElem::mutable_opclassopts(int index) { // @@protoc_insertion_point(field_mutable:pg_query.IndexElem.opclassopts) return _impl_.opclassopts_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* IndexElem::mutable_opclassopts() { // @@protoc_insertion_point(field_mutable_list:pg_query.IndexElem.opclassopts) return &_impl_.opclassopts_; } inline const ::pg_query::Node& IndexElem::_internal_opclassopts(int index) const { return _impl_.opclassopts_.Get(index); } inline const ::pg_query::Node& IndexElem::opclassopts(int index) const { // @@protoc_insertion_point(field_get:pg_query.IndexElem.opclassopts) return _internal_opclassopts(index); } inline ::pg_query::Node* IndexElem::_internal_add_opclassopts() { return _impl_.opclassopts_.Add(); } inline ::pg_query::Node* IndexElem::add_opclassopts() { ::pg_query::Node* _add = _internal_add_opclassopts(); // @@protoc_insertion_point(field_add:pg_query.IndexElem.opclassopts) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& IndexElem::opclassopts() const { // @@protoc_insertion_point(field_list:pg_query.IndexElem.opclassopts) return _impl_.opclassopts_; } // .pg_query.SortByDir ordering = 7 [json_name = "ordering"]; inline void IndexElem::clear_ordering() { _impl_.ordering_ = 0; } inline ::pg_query::SortByDir IndexElem::_internal_ordering() const { return static_cast< ::pg_query::SortByDir >(_impl_.ordering_); } inline ::pg_query::SortByDir IndexElem::ordering() const { // @@protoc_insertion_point(field_get:pg_query.IndexElem.ordering) return _internal_ordering(); } inline void IndexElem::_internal_set_ordering(::pg_query::SortByDir value) { _impl_.ordering_ = value; } inline void IndexElem::set_ordering(::pg_query::SortByDir value) { _internal_set_ordering(value); // @@protoc_insertion_point(field_set:pg_query.IndexElem.ordering) } // .pg_query.SortByNulls nulls_ordering = 8 [json_name = "nulls_ordering"]; inline void IndexElem::clear_nulls_ordering() { _impl_.nulls_ordering_ = 0; } inline ::pg_query::SortByNulls IndexElem::_internal_nulls_ordering() const { return static_cast< ::pg_query::SortByNulls >(_impl_.nulls_ordering_); } inline ::pg_query::SortByNulls IndexElem::nulls_ordering() const { // @@protoc_insertion_point(field_get:pg_query.IndexElem.nulls_ordering) return _internal_nulls_ordering(); } inline void IndexElem::_internal_set_nulls_ordering(::pg_query::SortByNulls value) { _impl_.nulls_ordering_ = value; } inline void IndexElem::set_nulls_ordering(::pg_query::SortByNulls value) { _internal_set_nulls_ordering(value); // @@protoc_insertion_point(field_set:pg_query.IndexElem.nulls_ordering) } // ------------------------------------------------------------------- // StatsElem // string name = 1 [json_name = "name"]; inline void StatsElem::clear_name() { _impl_.name_.ClearToEmpty(); } inline const std::string& StatsElem::name() const { // @@protoc_insertion_point(field_get:pg_query.StatsElem.name) return _internal_name(); } template inline PROTOBUF_ALWAYS_INLINE void StatsElem::set_name(ArgT0&& arg0, ArgT... args) { _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.StatsElem.name) } inline std::string* StatsElem::mutable_name() { 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 { return _impl_.name_.Get(); } inline void StatsElem::_internal_set_name(const std::string& value) { _impl_.name_.Set(value, GetArenaForAllocation()); } inline std::string* StatsElem::_internal_mutable_name() { return _impl_.name_.Mutable(GetArenaForAllocation()); } inline std::string* StatsElem::release_name() { // @@protoc_insertion_point(field_release:pg_query.StatsElem.name) return _impl_.name_.Release(); } inline void StatsElem::set_allocated_name(std::string* name) { if (name != nullptr) { } else { } _impl_.name_.SetAllocated(name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.name_.IsDefault()) { _impl_.name_.Set("", GetArenaForAllocation()); } #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::_internal_has_expr() const { return this != internal_default_instance() && _impl_.expr_ != nullptr; } inline bool StatsElem::has_expr() const { return _internal_has_expr(); } inline void StatsElem::clear_expr() { if (GetArenaForAllocation() == nullptr && _impl_.expr_ != nullptr) { delete _impl_.expr_; } _impl_.expr_ = nullptr; } inline const ::pg_query::Node& StatsElem::_internal_expr() const { const ::pg_query::Node* p = _impl_.expr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& StatsElem::expr() const { // @@protoc_insertion_point(field_get:pg_query.StatsElem.expr) return _internal_expr(); } inline void StatsElem::unsafe_arena_set_allocated_expr( ::pg_query::Node* expr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.expr_); } _impl_.expr_ = expr; if (expr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.StatsElem.expr) } inline ::pg_query::Node* StatsElem::release_expr() { ::pg_query::Node* temp = _impl_.expr_; _impl_.expr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* StatsElem::unsafe_arena_release_expr() { // @@protoc_insertion_point(field_release:pg_query.StatsElem.expr) ::pg_query::Node* temp = _impl_.expr_; _impl_.expr_ = nullptr; return temp; } inline ::pg_query::Node* StatsElem::_internal_mutable_expr() { if (_impl_.expr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.expr_ = p; } return _impl_.expr_; } inline ::pg_query::Node* StatsElem::mutable_expr() { ::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* expr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.expr_; } if (expr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(expr); if (message_arena != submessage_arena) { expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, expr, submessage_arena); } } else { } _impl_.expr_ = expr; // @@protoc_insertion_point(field_set_allocated:pg_query.StatsElem.expr) } // ------------------------------------------------------------------- // Constraint // .pg_query.ConstrType contype = 1 [json_name = "contype"]; inline void Constraint::clear_contype() { _impl_.contype_ = 0; } inline ::pg_query::ConstrType Constraint::_internal_contype() const { return static_cast< ::pg_query::ConstrType >(_impl_.contype_); } inline ::pg_query::ConstrType Constraint::contype() const { // @@protoc_insertion_point(field_get:pg_query.Constraint.contype) return _internal_contype(); } inline void Constraint::_internal_set_contype(::pg_query::ConstrType value) { _impl_.contype_ = value; } inline void Constraint::set_contype(::pg_query::ConstrType value) { _internal_set_contype(value); // @@protoc_insertion_point(field_set:pg_query.Constraint.contype) } // string conname = 2 [json_name = "conname"]; inline void Constraint::clear_conname() { _impl_.conname_.ClearToEmpty(); } inline const std::string& Constraint::conname() const { // @@protoc_insertion_point(field_get:pg_query.Constraint.conname) return _internal_conname(); } template inline PROTOBUF_ALWAYS_INLINE void Constraint::set_conname(ArgT0&& arg0, ArgT... args) { _impl_.conname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.Constraint.conname) } inline std::string* Constraint::mutable_conname() { 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 { return _impl_.conname_.Get(); } inline void Constraint::_internal_set_conname(const std::string& value) { _impl_.conname_.Set(value, GetArenaForAllocation()); } inline std::string* Constraint::_internal_mutable_conname() { return _impl_.conname_.Mutable(GetArenaForAllocation()); } inline std::string* Constraint::release_conname() { // @@protoc_insertion_point(field_release:pg_query.Constraint.conname) return _impl_.conname_.Release(); } inline void Constraint::set_allocated_conname(std::string* conname) { if (conname != nullptr) { } else { } _impl_.conname_.SetAllocated(conname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.conname_.IsDefault()) { _impl_.conname_.Set("", GetArenaForAllocation()); } #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() { _impl_.deferrable_ = false; } inline bool Constraint::_internal_deferrable() const { return _impl_.deferrable_; } inline bool Constraint::deferrable() const { // @@protoc_insertion_point(field_get:pg_query.Constraint.deferrable) return _internal_deferrable(); } inline void Constraint::_internal_set_deferrable(bool value) { _impl_.deferrable_ = value; } inline void Constraint::set_deferrable(bool value) { _internal_set_deferrable(value); // @@protoc_insertion_point(field_set:pg_query.Constraint.deferrable) } // bool initdeferred = 4 [json_name = "initdeferred"]; inline void Constraint::clear_initdeferred() { _impl_.initdeferred_ = false; } inline bool Constraint::_internal_initdeferred() const { return _impl_.initdeferred_; } inline bool Constraint::initdeferred() const { // @@protoc_insertion_point(field_get:pg_query.Constraint.initdeferred) return _internal_initdeferred(); } inline void Constraint::_internal_set_initdeferred(bool value) { _impl_.initdeferred_ = value; } inline void Constraint::set_initdeferred(bool value) { _internal_set_initdeferred(value); // @@protoc_insertion_point(field_set:pg_query.Constraint.initdeferred) } // int32 location = 5 [json_name = "location"]; inline void Constraint::clear_location() { _impl_.location_ = 0; } inline int32_t Constraint::_internal_location() const { return _impl_.location_; } inline int32_t Constraint::location() const { // @@protoc_insertion_point(field_get:pg_query.Constraint.location) return _internal_location(); } inline void Constraint::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void Constraint::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.Constraint.location) } // bool is_no_inherit = 6 [json_name = "is_no_inherit"]; inline void Constraint::clear_is_no_inherit() { _impl_.is_no_inherit_ = false; } inline bool Constraint::_internal_is_no_inherit() const { return _impl_.is_no_inherit_; } inline bool Constraint::is_no_inherit() const { // @@protoc_insertion_point(field_get:pg_query.Constraint.is_no_inherit) return _internal_is_no_inherit(); } inline void Constraint::_internal_set_is_no_inherit(bool value) { _impl_.is_no_inherit_ = value; } inline void Constraint::set_is_no_inherit(bool value) { _internal_set_is_no_inherit(value); // @@protoc_insertion_point(field_set:pg_query.Constraint.is_no_inherit) } // .pg_query.Node raw_expr = 7 [json_name = "raw_expr"]; inline bool Constraint::_internal_has_raw_expr() const { return this != internal_default_instance() && _impl_.raw_expr_ != nullptr; } inline bool Constraint::has_raw_expr() const { return _internal_has_raw_expr(); } inline void Constraint::clear_raw_expr() { if (GetArenaForAllocation() == nullptr && _impl_.raw_expr_ != nullptr) { delete _impl_.raw_expr_; } _impl_.raw_expr_ = nullptr; } inline const ::pg_query::Node& Constraint::_internal_raw_expr() const { const ::pg_query::Node* p = _impl_.raw_expr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& Constraint::raw_expr() const { // @@protoc_insertion_point(field_get:pg_query.Constraint.raw_expr) return _internal_raw_expr(); } inline void Constraint::unsafe_arena_set_allocated_raw_expr( ::pg_query::Node* raw_expr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.raw_expr_); } _impl_.raw_expr_ = raw_expr; if (raw_expr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Constraint.raw_expr) } inline ::pg_query::Node* Constraint::release_raw_expr() { ::pg_query::Node* temp = _impl_.raw_expr_; _impl_.raw_expr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* Constraint::unsafe_arena_release_raw_expr() { // @@protoc_insertion_point(field_release:pg_query.Constraint.raw_expr) ::pg_query::Node* temp = _impl_.raw_expr_; _impl_.raw_expr_ = nullptr; return temp; } inline ::pg_query::Node* Constraint::_internal_mutable_raw_expr() { if (_impl_.raw_expr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.raw_expr_ = p; } return _impl_.raw_expr_; } inline ::pg_query::Node* Constraint::mutable_raw_expr() { ::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* raw_expr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.raw_expr_; } if (raw_expr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(raw_expr); if (message_arena != submessage_arena) { raw_expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, raw_expr, submessage_arena); } } else { } _impl_.raw_expr_ = raw_expr; // @@protoc_insertion_point(field_set_allocated:pg_query.Constraint.raw_expr) } // string cooked_expr = 8 [json_name = "cooked_expr"]; inline void Constraint::clear_cooked_expr() { _impl_.cooked_expr_.ClearToEmpty(); } inline const std::string& Constraint::cooked_expr() const { // @@protoc_insertion_point(field_get:pg_query.Constraint.cooked_expr) return _internal_cooked_expr(); } template inline PROTOBUF_ALWAYS_INLINE void Constraint::set_cooked_expr(ArgT0&& arg0, ArgT... args) { _impl_.cooked_expr_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.Constraint.cooked_expr) } inline std::string* Constraint::mutable_cooked_expr() { 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 { return _impl_.cooked_expr_.Get(); } inline void Constraint::_internal_set_cooked_expr(const std::string& value) { _impl_.cooked_expr_.Set(value, GetArenaForAllocation()); } inline std::string* Constraint::_internal_mutable_cooked_expr() { return _impl_.cooked_expr_.Mutable(GetArenaForAllocation()); } inline std::string* Constraint::release_cooked_expr() { // @@protoc_insertion_point(field_release:pg_query.Constraint.cooked_expr) return _impl_.cooked_expr_.Release(); } inline void Constraint::set_allocated_cooked_expr(std::string* cooked_expr) { if (cooked_expr != nullptr) { } else { } _impl_.cooked_expr_.SetAllocated(cooked_expr, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.cooked_expr_.IsDefault()) { _impl_.cooked_expr_.Set("", GetArenaForAllocation()); } #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() { _impl_.generated_when_.ClearToEmpty(); } inline const std::string& Constraint::generated_when() const { // @@protoc_insertion_point(field_get:pg_query.Constraint.generated_when) return _internal_generated_when(); } template inline PROTOBUF_ALWAYS_INLINE void Constraint::set_generated_when(ArgT0&& arg0, ArgT... args) { _impl_.generated_when_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.Constraint.generated_when) } inline std::string* Constraint::mutable_generated_when() { 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 { return _impl_.generated_when_.Get(); } inline void Constraint::_internal_set_generated_when(const std::string& value) { _impl_.generated_when_.Set(value, GetArenaForAllocation()); } inline std::string* Constraint::_internal_mutable_generated_when() { return _impl_.generated_when_.Mutable(GetArenaForAllocation()); } inline std::string* Constraint::release_generated_when() { // @@protoc_insertion_point(field_release:pg_query.Constraint.generated_when) return _impl_.generated_when_.Release(); } inline void Constraint::set_allocated_generated_when(std::string* generated_when) { if (generated_when != nullptr) { } else { } _impl_.generated_when_.SetAllocated(generated_when, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.generated_when_.IsDefault()) { _impl_.generated_when_.Set("", GetArenaForAllocation()); } #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() { _impl_.nulls_not_distinct_ = false; } inline bool Constraint::_internal_nulls_not_distinct() const { return _impl_.nulls_not_distinct_; } 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::_internal_set_nulls_not_distinct(bool value) { _impl_.nulls_not_distinct_ = value; } 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) } // repeated .pg_query.Node keys = 11 [json_name = "keys"]; inline int Constraint::_internal_keys_size() const { return _impl_.keys_.size(); } inline int Constraint::keys_size() const { return _internal_keys_size(); } inline void Constraint::clear_keys() { _impl_.keys_.Clear(); } inline ::pg_query::Node* Constraint::mutable_keys(int index) { // @@protoc_insertion_point(field_mutable:pg_query.Constraint.keys) return _impl_.keys_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* Constraint::mutable_keys() { // @@protoc_insertion_point(field_mutable_list:pg_query.Constraint.keys) return &_impl_.keys_; } inline const ::pg_query::Node& Constraint::_internal_keys(int index) const { return _impl_.keys_.Get(index); } inline const ::pg_query::Node& Constraint::keys(int index) const { // @@protoc_insertion_point(field_get:pg_query.Constraint.keys) return _internal_keys(index); } inline ::pg_query::Node* Constraint::_internal_add_keys() { return _impl_.keys_.Add(); } inline ::pg_query::Node* Constraint::add_keys() { ::pg_query::Node* _add = _internal_add_keys(); // @@protoc_insertion_point(field_add:pg_query.Constraint.keys) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& Constraint::keys() const { // @@protoc_insertion_point(field_list:pg_query.Constraint.keys) return _impl_.keys_; } // repeated .pg_query.Node including = 12 [json_name = "including"]; inline int Constraint::_internal_including_size() const { return _impl_.including_.size(); } inline int Constraint::including_size() const { return _internal_including_size(); } inline void Constraint::clear_including() { _impl_.including_.Clear(); } inline ::pg_query::Node* Constraint::mutable_including(int index) { // @@protoc_insertion_point(field_mutable:pg_query.Constraint.including) return _impl_.including_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* Constraint::mutable_including() { // @@protoc_insertion_point(field_mutable_list:pg_query.Constraint.including) return &_impl_.including_; } inline const ::pg_query::Node& Constraint::_internal_including(int index) const { return _impl_.including_.Get(index); } inline const ::pg_query::Node& Constraint::including(int index) const { // @@protoc_insertion_point(field_get:pg_query.Constraint.including) return _internal_including(index); } inline ::pg_query::Node* Constraint::_internal_add_including() { return _impl_.including_.Add(); } inline ::pg_query::Node* Constraint::add_including() { ::pg_query::Node* _add = _internal_add_including(); // @@protoc_insertion_point(field_add:pg_query.Constraint.including) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& Constraint::including() const { // @@protoc_insertion_point(field_list:pg_query.Constraint.including) return _impl_.including_; } // repeated .pg_query.Node exclusions = 13 [json_name = "exclusions"]; inline int Constraint::_internal_exclusions_size() const { return _impl_.exclusions_.size(); } inline int Constraint::exclusions_size() const { return _internal_exclusions_size(); } inline void Constraint::clear_exclusions() { _impl_.exclusions_.Clear(); } inline ::pg_query::Node* Constraint::mutable_exclusions(int index) { // @@protoc_insertion_point(field_mutable:pg_query.Constraint.exclusions) return _impl_.exclusions_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* Constraint::mutable_exclusions() { // @@protoc_insertion_point(field_mutable_list:pg_query.Constraint.exclusions) return &_impl_.exclusions_; } inline const ::pg_query::Node& Constraint::_internal_exclusions(int index) const { return _impl_.exclusions_.Get(index); } inline const ::pg_query::Node& Constraint::exclusions(int index) const { // @@protoc_insertion_point(field_get:pg_query.Constraint.exclusions) return _internal_exclusions(index); } inline ::pg_query::Node* Constraint::_internal_add_exclusions() { return _impl_.exclusions_.Add(); } inline ::pg_query::Node* Constraint::add_exclusions() { ::pg_query::Node* _add = _internal_add_exclusions(); // @@protoc_insertion_point(field_add:pg_query.Constraint.exclusions) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& Constraint::exclusions() const { // @@protoc_insertion_point(field_list:pg_query.Constraint.exclusions) return _impl_.exclusions_; } // repeated .pg_query.Node options = 14 [json_name = "options"]; inline int Constraint::_internal_options_size() const { return _impl_.options_.size(); } inline int Constraint::options_size() const { return _internal_options_size(); } inline void Constraint::clear_options() { _impl_.options_.Clear(); } inline ::pg_query::Node* Constraint::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:pg_query.Constraint.options) return _impl_.options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* Constraint::mutable_options() { // @@protoc_insertion_point(field_mutable_list:pg_query.Constraint.options) return &_impl_.options_; } inline const ::pg_query::Node& Constraint::_internal_options(int index) const { return _impl_.options_.Get(index); } inline const ::pg_query::Node& Constraint::options(int index) const { // @@protoc_insertion_point(field_get:pg_query.Constraint.options) return _internal_options(index); } inline ::pg_query::Node* Constraint::_internal_add_options() { return _impl_.options_.Add(); } inline ::pg_query::Node* Constraint::add_options() { ::pg_query::Node* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:pg_query.Constraint.options) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& Constraint::options() const { // @@protoc_insertion_point(field_list:pg_query.Constraint.options) return _impl_.options_; } // string indexname = 15 [json_name = "indexname"]; inline void Constraint::clear_indexname() { _impl_.indexname_.ClearToEmpty(); } inline const std::string& Constraint::indexname() const { // @@protoc_insertion_point(field_get:pg_query.Constraint.indexname) return _internal_indexname(); } template inline PROTOBUF_ALWAYS_INLINE void Constraint::set_indexname(ArgT0&& arg0, ArgT... args) { _impl_.indexname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.Constraint.indexname) } inline std::string* Constraint::mutable_indexname() { 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 { return _impl_.indexname_.Get(); } inline void Constraint::_internal_set_indexname(const std::string& value) { _impl_.indexname_.Set(value, GetArenaForAllocation()); } inline std::string* Constraint::_internal_mutable_indexname() { return _impl_.indexname_.Mutable(GetArenaForAllocation()); } inline std::string* Constraint::release_indexname() { // @@protoc_insertion_point(field_release:pg_query.Constraint.indexname) return _impl_.indexname_.Release(); } inline void Constraint::set_allocated_indexname(std::string* indexname) { if (indexname != nullptr) { } else { } _impl_.indexname_.SetAllocated(indexname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.indexname_.IsDefault()) { _impl_.indexname_.Set("", GetArenaForAllocation()); } #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() { _impl_.indexspace_.ClearToEmpty(); } inline const std::string& Constraint::indexspace() const { // @@protoc_insertion_point(field_get:pg_query.Constraint.indexspace) return _internal_indexspace(); } template inline PROTOBUF_ALWAYS_INLINE void Constraint::set_indexspace(ArgT0&& arg0, ArgT... args) { _impl_.indexspace_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.Constraint.indexspace) } inline std::string* Constraint::mutable_indexspace() { 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 { return _impl_.indexspace_.Get(); } inline void Constraint::_internal_set_indexspace(const std::string& value) { _impl_.indexspace_.Set(value, GetArenaForAllocation()); } inline std::string* Constraint::_internal_mutable_indexspace() { return _impl_.indexspace_.Mutable(GetArenaForAllocation()); } inline std::string* Constraint::release_indexspace() { // @@protoc_insertion_point(field_release:pg_query.Constraint.indexspace) return _impl_.indexspace_.Release(); } inline void Constraint::set_allocated_indexspace(std::string* indexspace) { if (indexspace != nullptr) { } else { } _impl_.indexspace_.SetAllocated(indexspace, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.indexspace_.IsDefault()) { _impl_.indexspace_.Set("", GetArenaForAllocation()); } #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() { _impl_.reset_default_tblspc_ = false; } inline bool Constraint::_internal_reset_default_tblspc() const { return _impl_.reset_default_tblspc_; } inline bool Constraint::reset_default_tblspc() const { // @@protoc_insertion_point(field_get:pg_query.Constraint.reset_default_tblspc) return _internal_reset_default_tblspc(); } inline void Constraint::_internal_set_reset_default_tblspc(bool value) { _impl_.reset_default_tblspc_ = value; } inline void Constraint::set_reset_default_tblspc(bool value) { _internal_set_reset_default_tblspc(value); // @@protoc_insertion_point(field_set:pg_query.Constraint.reset_default_tblspc) } // string access_method = 18 [json_name = "access_method"]; inline void Constraint::clear_access_method() { _impl_.access_method_.ClearToEmpty(); } inline const std::string& Constraint::access_method() const { // @@protoc_insertion_point(field_get:pg_query.Constraint.access_method) return _internal_access_method(); } template inline PROTOBUF_ALWAYS_INLINE void Constraint::set_access_method(ArgT0&& arg0, ArgT... args) { _impl_.access_method_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.Constraint.access_method) } inline std::string* Constraint::mutable_access_method() { 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 { return _impl_.access_method_.Get(); } inline void Constraint::_internal_set_access_method(const std::string& value) { _impl_.access_method_.Set(value, GetArenaForAllocation()); } inline std::string* Constraint::_internal_mutable_access_method() { return _impl_.access_method_.Mutable(GetArenaForAllocation()); } inline std::string* Constraint::release_access_method() { // @@protoc_insertion_point(field_release:pg_query.Constraint.access_method) return _impl_.access_method_.Release(); } inline void Constraint::set_allocated_access_method(std::string* access_method) { if (access_method != nullptr) { } else { } _impl_.access_method_.SetAllocated(access_method, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.access_method_.IsDefault()) { _impl_.access_method_.Set("", GetArenaForAllocation()); } #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::_internal_has_where_clause() const { return this != internal_default_instance() && _impl_.where_clause_ != nullptr; } inline bool Constraint::has_where_clause() const { return _internal_has_where_clause(); } inline void Constraint::clear_where_clause() { if (GetArenaForAllocation() == nullptr && _impl_.where_clause_ != nullptr) { delete _impl_.where_clause_; } _impl_.where_clause_ = nullptr; } inline const ::pg_query::Node& Constraint::_internal_where_clause() const { const ::pg_query::Node* p = _impl_.where_clause_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& Constraint::where_clause() const { // @@protoc_insertion_point(field_get:pg_query.Constraint.where_clause) return _internal_where_clause(); } inline void Constraint::unsafe_arena_set_allocated_where_clause( ::pg_query::Node* where_clause) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.where_clause_); } _impl_.where_clause_ = where_clause; if (where_clause) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Constraint.where_clause) } inline ::pg_query::Node* Constraint::release_where_clause() { ::pg_query::Node* temp = _impl_.where_clause_; _impl_.where_clause_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* Constraint::unsafe_arena_release_where_clause() { // @@protoc_insertion_point(field_release:pg_query.Constraint.where_clause) ::pg_query::Node* temp = _impl_.where_clause_; _impl_.where_clause_ = nullptr; return temp; } inline ::pg_query::Node* Constraint::_internal_mutable_where_clause() { if (_impl_.where_clause_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.where_clause_ = p; } return _impl_.where_clause_; } inline ::pg_query::Node* Constraint::mutable_where_clause() { ::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* where_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.where_clause_; } if (where_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(where_clause); if (message_arena != submessage_arena) { where_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, where_clause, submessage_arena); } } else { } _impl_.where_clause_ = where_clause; // @@protoc_insertion_point(field_set_allocated:pg_query.Constraint.where_clause) } // .pg_query.RangeVar pktable = 20 [json_name = "pktable"]; inline bool Constraint::_internal_has_pktable() const { return this != internal_default_instance() && _impl_.pktable_ != nullptr; } inline bool Constraint::has_pktable() const { return _internal_has_pktable(); } inline void Constraint::clear_pktable() { if (GetArenaForAllocation() == nullptr && _impl_.pktable_ != nullptr) { delete _impl_.pktable_; } _impl_.pktable_ = nullptr; } inline const ::pg_query::RangeVar& Constraint::_internal_pktable() const { const ::pg_query::RangeVar* p = _impl_.pktable_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& Constraint::pktable() const { // @@protoc_insertion_point(field_get:pg_query.Constraint.pktable) return _internal_pktable(); } inline void Constraint::unsafe_arena_set_allocated_pktable( ::pg_query::RangeVar* pktable) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pktable_); } _impl_.pktable_ = pktable; if (pktable) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.Constraint.pktable) } inline ::pg_query::RangeVar* Constraint::release_pktable() { ::pg_query::RangeVar* temp = _impl_.pktable_; _impl_.pktable_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* Constraint::unsafe_arena_release_pktable() { // @@protoc_insertion_point(field_release:pg_query.Constraint.pktable) ::pg_query::RangeVar* temp = _impl_.pktable_; _impl_.pktable_ = nullptr; return temp; } inline ::pg_query::RangeVar* Constraint::_internal_mutable_pktable() { if (_impl_.pktable_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.pktable_ = p; } return _impl_.pktable_; } inline ::pg_query::RangeVar* Constraint::mutable_pktable() { ::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* pktable) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.pktable_; } if (pktable) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pktable); if (message_arena != submessage_arena) { pktable = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, pktable, submessage_arena); } } else { } _impl_.pktable_ = pktable; // @@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 _impl_.fk_attrs_.size(); } inline int Constraint::fk_attrs_size() const { return _internal_fk_attrs_size(); } inline void Constraint::clear_fk_attrs() { _impl_.fk_attrs_.Clear(); } inline ::pg_query::Node* Constraint::mutable_fk_attrs(int index) { // @@protoc_insertion_point(field_mutable:pg_query.Constraint.fk_attrs) return _impl_.fk_attrs_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* Constraint::mutable_fk_attrs() { // @@protoc_insertion_point(field_mutable_list:pg_query.Constraint.fk_attrs) return &_impl_.fk_attrs_; } inline const ::pg_query::Node& Constraint::_internal_fk_attrs(int index) const { return _impl_.fk_attrs_.Get(index); } inline const ::pg_query::Node& Constraint::fk_attrs(int index) const { // @@protoc_insertion_point(field_get:pg_query.Constraint.fk_attrs) return _internal_fk_attrs(index); } inline ::pg_query::Node* Constraint::_internal_add_fk_attrs() { return _impl_.fk_attrs_.Add(); } inline ::pg_query::Node* Constraint::add_fk_attrs() { ::pg_query::Node* _add = _internal_add_fk_attrs(); // @@protoc_insertion_point(field_add:pg_query.Constraint.fk_attrs) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& Constraint::fk_attrs() const { // @@protoc_insertion_point(field_list:pg_query.Constraint.fk_attrs) return _impl_.fk_attrs_; } // repeated .pg_query.Node pk_attrs = 22 [json_name = "pk_attrs"]; inline int Constraint::_internal_pk_attrs_size() const { return _impl_.pk_attrs_.size(); } inline int Constraint::pk_attrs_size() const { return _internal_pk_attrs_size(); } inline void Constraint::clear_pk_attrs() { _impl_.pk_attrs_.Clear(); } inline ::pg_query::Node* Constraint::mutable_pk_attrs(int index) { // @@protoc_insertion_point(field_mutable:pg_query.Constraint.pk_attrs) return _impl_.pk_attrs_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* Constraint::mutable_pk_attrs() { // @@protoc_insertion_point(field_mutable_list:pg_query.Constraint.pk_attrs) return &_impl_.pk_attrs_; } inline const ::pg_query::Node& Constraint::_internal_pk_attrs(int index) const { return _impl_.pk_attrs_.Get(index); } inline const ::pg_query::Node& Constraint::pk_attrs(int index) const { // @@protoc_insertion_point(field_get:pg_query.Constraint.pk_attrs) return _internal_pk_attrs(index); } inline ::pg_query::Node* Constraint::_internal_add_pk_attrs() { return _impl_.pk_attrs_.Add(); } inline ::pg_query::Node* Constraint::add_pk_attrs() { ::pg_query::Node* _add = _internal_add_pk_attrs(); // @@protoc_insertion_point(field_add:pg_query.Constraint.pk_attrs) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& Constraint::pk_attrs() const { // @@protoc_insertion_point(field_list:pg_query.Constraint.pk_attrs) return _impl_.pk_attrs_; } // string fk_matchtype = 23 [json_name = "fk_matchtype"]; inline void Constraint::clear_fk_matchtype() { _impl_.fk_matchtype_.ClearToEmpty(); } inline const std::string& Constraint::fk_matchtype() const { // @@protoc_insertion_point(field_get:pg_query.Constraint.fk_matchtype) return _internal_fk_matchtype(); } template inline PROTOBUF_ALWAYS_INLINE void Constraint::set_fk_matchtype(ArgT0&& arg0, ArgT... args) { _impl_.fk_matchtype_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.Constraint.fk_matchtype) } inline std::string* Constraint::mutable_fk_matchtype() { 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 { return _impl_.fk_matchtype_.Get(); } inline void Constraint::_internal_set_fk_matchtype(const std::string& value) { _impl_.fk_matchtype_.Set(value, GetArenaForAllocation()); } inline std::string* Constraint::_internal_mutable_fk_matchtype() { return _impl_.fk_matchtype_.Mutable(GetArenaForAllocation()); } inline std::string* Constraint::release_fk_matchtype() { // @@protoc_insertion_point(field_release:pg_query.Constraint.fk_matchtype) return _impl_.fk_matchtype_.Release(); } inline void Constraint::set_allocated_fk_matchtype(std::string* fk_matchtype) { if (fk_matchtype != nullptr) { } else { } _impl_.fk_matchtype_.SetAllocated(fk_matchtype, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.fk_matchtype_.IsDefault()) { _impl_.fk_matchtype_.Set("", GetArenaForAllocation()); } #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() { _impl_.fk_upd_action_.ClearToEmpty(); } inline const std::string& Constraint::fk_upd_action() const { // @@protoc_insertion_point(field_get:pg_query.Constraint.fk_upd_action) return _internal_fk_upd_action(); } template inline PROTOBUF_ALWAYS_INLINE void Constraint::set_fk_upd_action(ArgT0&& arg0, ArgT... args) { _impl_.fk_upd_action_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.Constraint.fk_upd_action) } inline std::string* Constraint::mutable_fk_upd_action() { 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 { return _impl_.fk_upd_action_.Get(); } inline void Constraint::_internal_set_fk_upd_action(const std::string& value) { _impl_.fk_upd_action_.Set(value, GetArenaForAllocation()); } inline std::string* Constraint::_internal_mutable_fk_upd_action() { return _impl_.fk_upd_action_.Mutable(GetArenaForAllocation()); } inline std::string* Constraint::release_fk_upd_action() { // @@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* fk_upd_action) { if (fk_upd_action != nullptr) { } else { } _impl_.fk_upd_action_.SetAllocated(fk_upd_action, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.fk_upd_action_.IsDefault()) { _impl_.fk_upd_action_.Set("", GetArenaForAllocation()); } #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() { _impl_.fk_del_action_.ClearToEmpty(); } inline const std::string& Constraint::fk_del_action() const { // @@protoc_insertion_point(field_get:pg_query.Constraint.fk_del_action) return _internal_fk_del_action(); } template inline PROTOBUF_ALWAYS_INLINE void Constraint::set_fk_del_action(ArgT0&& arg0, ArgT... args) { _impl_.fk_del_action_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.Constraint.fk_del_action) } inline std::string* Constraint::mutable_fk_del_action() { 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 { return _impl_.fk_del_action_.Get(); } inline void Constraint::_internal_set_fk_del_action(const std::string& value) { _impl_.fk_del_action_.Set(value, GetArenaForAllocation()); } inline std::string* Constraint::_internal_mutable_fk_del_action() { return _impl_.fk_del_action_.Mutable(GetArenaForAllocation()); } inline std::string* Constraint::release_fk_del_action() { // @@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* fk_del_action) { if (fk_del_action != nullptr) { } else { } _impl_.fk_del_action_.SetAllocated(fk_del_action, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.fk_del_action_.IsDefault()) { _impl_.fk_del_action_.Set("", GetArenaForAllocation()); } #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 _impl_.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() { _impl_.fk_del_set_cols_.Clear(); } inline ::pg_query::Node* Constraint::mutable_fk_del_set_cols(int index) { // @@protoc_insertion_point(field_mutable:pg_query.Constraint.fk_del_set_cols) return _impl_.fk_del_set_cols_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* Constraint::mutable_fk_del_set_cols() { // @@protoc_insertion_point(field_mutable_list:pg_query.Constraint.fk_del_set_cols) return &_impl_.fk_del_set_cols_; } inline const ::pg_query::Node& Constraint::_internal_fk_del_set_cols(int index) const { return _impl_.fk_del_set_cols_.Get(index); } inline const ::pg_query::Node& Constraint::fk_del_set_cols(int index) const { // @@protoc_insertion_point(field_get:pg_query.Constraint.fk_del_set_cols) return _internal_fk_del_set_cols(index); } inline ::pg_query::Node* Constraint::_internal_add_fk_del_set_cols() { return _impl_.fk_del_set_cols_.Add(); } inline ::pg_query::Node* Constraint::add_fk_del_set_cols() { ::pg_query::Node* _add = _internal_add_fk_del_set_cols(); // @@protoc_insertion_point(field_add:pg_query.Constraint.fk_del_set_cols) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& Constraint::fk_del_set_cols() const { // @@protoc_insertion_point(field_list:pg_query.Constraint.fk_del_set_cols) 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 _impl_.old_conpfeqop_.size(); } inline int Constraint::old_conpfeqop_size() const { return _internal_old_conpfeqop_size(); } inline void Constraint::clear_old_conpfeqop() { _impl_.old_conpfeqop_.Clear(); } inline ::pg_query::Node* Constraint::mutable_old_conpfeqop(int index) { // @@protoc_insertion_point(field_mutable:pg_query.Constraint.old_conpfeqop) return _impl_.old_conpfeqop_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* Constraint::mutable_old_conpfeqop() { // @@protoc_insertion_point(field_mutable_list:pg_query.Constraint.old_conpfeqop) return &_impl_.old_conpfeqop_; } inline const ::pg_query::Node& Constraint::_internal_old_conpfeqop(int index) const { return _impl_.old_conpfeqop_.Get(index); } inline const ::pg_query::Node& Constraint::old_conpfeqop(int index) const { // @@protoc_insertion_point(field_get:pg_query.Constraint.old_conpfeqop) return _internal_old_conpfeqop(index); } inline ::pg_query::Node* Constraint::_internal_add_old_conpfeqop() { return _impl_.old_conpfeqop_.Add(); } inline ::pg_query::Node* Constraint::add_old_conpfeqop() { ::pg_query::Node* _add = _internal_add_old_conpfeqop(); // @@protoc_insertion_point(field_add:pg_query.Constraint.old_conpfeqop) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& Constraint::old_conpfeqop() const { // @@protoc_insertion_point(field_list:pg_query.Constraint.old_conpfeqop) return _impl_.old_conpfeqop_; } // uint32 old_pktable_oid = 28 [json_name = "old_pktable_oid"]; inline void Constraint::clear_old_pktable_oid() { _impl_.old_pktable_oid_ = 0u; } inline uint32_t Constraint::_internal_old_pktable_oid() const { return _impl_.old_pktable_oid_; } 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::_internal_set_old_pktable_oid(uint32_t value) { _impl_.old_pktable_oid_ = value; } 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) } // bool skip_validation = 29 [json_name = "skip_validation"]; inline void Constraint::clear_skip_validation() { _impl_.skip_validation_ = false; } inline bool Constraint::_internal_skip_validation() const { return _impl_.skip_validation_; } inline bool Constraint::skip_validation() const { // @@protoc_insertion_point(field_get:pg_query.Constraint.skip_validation) return _internal_skip_validation(); } inline void Constraint::_internal_set_skip_validation(bool value) { _impl_.skip_validation_ = value; } inline void Constraint::set_skip_validation(bool value) { _internal_set_skip_validation(value); // @@protoc_insertion_point(field_set:pg_query.Constraint.skip_validation) } // bool initially_valid = 30 [json_name = "initially_valid"]; inline void Constraint::clear_initially_valid() { _impl_.initially_valid_ = false; } inline bool Constraint::_internal_initially_valid() const { return _impl_.initially_valid_; } inline bool Constraint::initially_valid() const { // @@protoc_insertion_point(field_get:pg_query.Constraint.initially_valid) return _internal_initially_valid(); } inline void Constraint::_internal_set_initially_valid(bool value) { _impl_.initially_valid_ = value; } inline void Constraint::set_initially_valid(bool value) { _internal_set_initially_valid(value); // @@protoc_insertion_point(field_set:pg_query.Constraint.initially_valid) } // ------------------------------------------------------------------- // DefElem // string defnamespace = 1 [json_name = "defnamespace"]; inline void DefElem::clear_defnamespace() { _impl_.defnamespace_.ClearToEmpty(); } inline const std::string& DefElem::defnamespace() const { // @@protoc_insertion_point(field_get:pg_query.DefElem.defnamespace) return _internal_defnamespace(); } template inline PROTOBUF_ALWAYS_INLINE void DefElem::set_defnamespace(ArgT0&& arg0, ArgT... args) { _impl_.defnamespace_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.DefElem.defnamespace) } inline std::string* DefElem::mutable_defnamespace() { 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 { return _impl_.defnamespace_.Get(); } inline void DefElem::_internal_set_defnamespace(const std::string& value) { _impl_.defnamespace_.Set(value, GetArenaForAllocation()); } inline std::string* DefElem::_internal_mutable_defnamespace() { return _impl_.defnamespace_.Mutable(GetArenaForAllocation()); } inline std::string* DefElem::release_defnamespace() { // @@protoc_insertion_point(field_release:pg_query.DefElem.defnamespace) return _impl_.defnamespace_.Release(); } inline void DefElem::set_allocated_defnamespace(std::string* defnamespace) { if (defnamespace != nullptr) { } else { } _impl_.defnamespace_.SetAllocated(defnamespace, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.defnamespace_.IsDefault()) { _impl_.defnamespace_.Set("", GetArenaForAllocation()); } #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() { _impl_.defname_.ClearToEmpty(); } inline const std::string& DefElem::defname() const { // @@protoc_insertion_point(field_get:pg_query.DefElem.defname) return _internal_defname(); } template inline PROTOBUF_ALWAYS_INLINE void DefElem::set_defname(ArgT0&& arg0, ArgT... args) { _impl_.defname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.DefElem.defname) } inline std::string* DefElem::mutable_defname() { 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 { return _impl_.defname_.Get(); } inline void DefElem::_internal_set_defname(const std::string& value) { _impl_.defname_.Set(value, GetArenaForAllocation()); } inline std::string* DefElem::_internal_mutable_defname() { return _impl_.defname_.Mutable(GetArenaForAllocation()); } inline std::string* DefElem::release_defname() { // @@protoc_insertion_point(field_release:pg_query.DefElem.defname) return _impl_.defname_.Release(); } inline void DefElem::set_allocated_defname(std::string* defname) { if (defname != nullptr) { } else { } _impl_.defname_.SetAllocated(defname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.defname_.IsDefault()) { _impl_.defname_.Set("", GetArenaForAllocation()); } #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::_internal_has_arg() const { return this != internal_default_instance() && _impl_.arg_ != nullptr; } inline bool DefElem::has_arg() const { return _internal_has_arg(); } inline void DefElem::clear_arg() { if (GetArenaForAllocation() == nullptr && _impl_.arg_ != nullptr) { delete _impl_.arg_; } _impl_.arg_ = nullptr; } inline const ::pg_query::Node& DefElem::_internal_arg() const { const ::pg_query::Node* p = _impl_.arg_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& DefElem::arg() const { // @@protoc_insertion_point(field_get:pg_query.DefElem.arg) return _internal_arg(); } inline void DefElem::unsafe_arena_set_allocated_arg( ::pg_query::Node* arg) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.arg_); } _impl_.arg_ = arg; if (arg) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.DefElem.arg) } inline ::pg_query::Node* DefElem::release_arg() { ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* DefElem::unsafe_arena_release_arg() { // @@protoc_insertion_point(field_release:pg_query.DefElem.arg) ::pg_query::Node* temp = _impl_.arg_; _impl_.arg_ = nullptr; return temp; } inline ::pg_query::Node* DefElem::_internal_mutable_arg() { if (_impl_.arg_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.arg_ = p; } return _impl_.arg_; } inline ::pg_query::Node* DefElem::mutable_arg() { ::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* arg) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.arg_; } if (arg) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(arg); if (message_arena != submessage_arena) { arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, arg, submessage_arena); } } else { } _impl_.arg_ = arg; // @@protoc_insertion_point(field_set_allocated:pg_query.DefElem.arg) } // .pg_query.DefElemAction defaction = 4 [json_name = "defaction"]; inline void DefElem::clear_defaction() { _impl_.defaction_ = 0; } inline ::pg_query::DefElemAction DefElem::_internal_defaction() const { return static_cast< ::pg_query::DefElemAction >(_impl_.defaction_); } inline ::pg_query::DefElemAction DefElem::defaction() const { // @@protoc_insertion_point(field_get:pg_query.DefElem.defaction) return _internal_defaction(); } inline void DefElem::_internal_set_defaction(::pg_query::DefElemAction value) { _impl_.defaction_ = value; } inline void DefElem::set_defaction(::pg_query::DefElemAction value) { _internal_set_defaction(value); // @@protoc_insertion_point(field_set:pg_query.DefElem.defaction) } // int32 location = 5 [json_name = "location"]; inline void DefElem::clear_location() { _impl_.location_ = 0; } inline int32_t DefElem::_internal_location() const { return _impl_.location_; } inline int32_t DefElem::location() const { // @@protoc_insertion_point(field_get:pg_query.DefElem.location) return _internal_location(); } inline void DefElem::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void DefElem::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.DefElem.location) } // ------------------------------------------------------------------- // RangeTblEntry // .pg_query.RTEKind rtekind = 1 [json_name = "rtekind"]; inline void RangeTblEntry::clear_rtekind() { _impl_.rtekind_ = 0; } inline ::pg_query::RTEKind RangeTblEntry::_internal_rtekind() const { return static_cast< ::pg_query::RTEKind >(_impl_.rtekind_); } inline ::pg_query::RTEKind RangeTblEntry::rtekind() const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.rtekind) return _internal_rtekind(); } inline void RangeTblEntry::_internal_set_rtekind(::pg_query::RTEKind value) { _impl_.rtekind_ = value; } inline void RangeTblEntry::set_rtekind(::pg_query::RTEKind value) { _internal_set_rtekind(value); // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.rtekind) } // uint32 relid = 2 [json_name = "relid"]; inline void RangeTblEntry::clear_relid() { _impl_.relid_ = 0u; } inline uint32_t RangeTblEntry::_internal_relid() const { return _impl_.relid_; } inline uint32_t RangeTblEntry::relid() const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.relid) return _internal_relid(); } inline void RangeTblEntry::_internal_set_relid(uint32_t value) { _impl_.relid_ = value; } inline void RangeTblEntry::set_relid(uint32_t value) { _internal_set_relid(value); // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.relid) } // string relkind = 3 [json_name = "relkind"]; inline void RangeTblEntry::clear_relkind() { _impl_.relkind_.ClearToEmpty(); } inline const std::string& RangeTblEntry::relkind() const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.relkind) return _internal_relkind(); } template inline PROTOBUF_ALWAYS_INLINE void RangeTblEntry::set_relkind(ArgT0&& arg0, ArgT... args) { _impl_.relkind_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.relkind) } inline std::string* RangeTblEntry::mutable_relkind() { 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 { return _impl_.relkind_.Get(); } inline void RangeTblEntry::_internal_set_relkind(const std::string& value) { _impl_.relkind_.Set(value, GetArenaForAllocation()); } inline std::string* RangeTblEntry::_internal_mutable_relkind() { return _impl_.relkind_.Mutable(GetArenaForAllocation()); } inline std::string* RangeTblEntry::release_relkind() { // @@protoc_insertion_point(field_release:pg_query.RangeTblEntry.relkind) return _impl_.relkind_.Release(); } inline void RangeTblEntry::set_allocated_relkind(std::string* relkind) { if (relkind != nullptr) { } else { } _impl_.relkind_.SetAllocated(relkind, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.relkind_.IsDefault()) { _impl_.relkind_.Set("", GetArenaForAllocation()); } #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() { _impl_.rellockmode_ = 0; } inline int32_t RangeTblEntry::_internal_rellockmode() const { return _impl_.rellockmode_; } inline int32_t RangeTblEntry::rellockmode() const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.rellockmode) return _internal_rellockmode(); } inline void RangeTblEntry::_internal_set_rellockmode(int32_t value) { _impl_.rellockmode_ = value; } inline void RangeTblEntry::set_rellockmode(int32_t value) { _internal_set_rellockmode(value); // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.rellockmode) } // .pg_query.TableSampleClause tablesample = 5 [json_name = "tablesample"]; inline bool RangeTblEntry::_internal_has_tablesample() const { return this != internal_default_instance() && _impl_.tablesample_ != nullptr; } inline bool RangeTblEntry::has_tablesample() const { return _internal_has_tablesample(); } inline void RangeTblEntry::clear_tablesample() { if (GetArenaForAllocation() == nullptr && _impl_.tablesample_ != nullptr) { delete _impl_.tablesample_; } _impl_.tablesample_ = nullptr; } inline const ::pg_query::TableSampleClause& RangeTblEntry::_internal_tablesample() const { const ::pg_query::TableSampleClause* p = _impl_.tablesample_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_TableSampleClause_default_instance_); } inline const ::pg_query::TableSampleClause& RangeTblEntry::tablesample() const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.tablesample) return _internal_tablesample(); } inline void RangeTblEntry::unsafe_arena_set_allocated_tablesample( ::pg_query::TableSampleClause* tablesample) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tablesample_); } _impl_.tablesample_ = tablesample; if (tablesample) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTblEntry.tablesample) } inline ::pg_query::TableSampleClause* RangeTblEntry::release_tablesample() { ::pg_query::TableSampleClause* temp = _impl_.tablesample_; _impl_.tablesample_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::TableSampleClause* RangeTblEntry::unsafe_arena_release_tablesample() { // @@protoc_insertion_point(field_release:pg_query.RangeTblEntry.tablesample) ::pg_query::TableSampleClause* temp = _impl_.tablesample_; _impl_.tablesample_ = nullptr; return temp; } inline ::pg_query::TableSampleClause* RangeTblEntry::_internal_mutable_tablesample() { if (_impl_.tablesample_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::TableSampleClause>(GetArenaForAllocation()); _impl_.tablesample_ = p; } return _impl_.tablesample_; } inline ::pg_query::TableSampleClause* RangeTblEntry::mutable_tablesample() { ::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* tablesample) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.tablesample_; } if (tablesample) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(tablesample); if (message_arena != submessage_arena) { tablesample = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, tablesample, submessage_arena); } } else { } _impl_.tablesample_ = tablesample; // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTblEntry.tablesample) } // .pg_query.Query subquery = 6 [json_name = "subquery"]; inline bool RangeTblEntry::_internal_has_subquery() const { return this != internal_default_instance() && _impl_.subquery_ != nullptr; } inline bool RangeTblEntry::has_subquery() const { return _internal_has_subquery(); } inline void RangeTblEntry::clear_subquery() { if (GetArenaForAllocation() == nullptr && _impl_.subquery_ != nullptr) { delete _impl_.subquery_; } _impl_.subquery_ = nullptr; } inline const ::pg_query::Query& RangeTblEntry::_internal_subquery() const { const ::pg_query::Query* p = _impl_.subquery_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Query_default_instance_); } inline const ::pg_query::Query& RangeTblEntry::subquery() const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.subquery) return _internal_subquery(); } inline void RangeTblEntry::unsafe_arena_set_allocated_subquery( ::pg_query::Query* subquery) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.subquery_); } _impl_.subquery_ = subquery; if (subquery) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTblEntry.subquery) } inline ::pg_query::Query* RangeTblEntry::release_subquery() { ::pg_query::Query* temp = _impl_.subquery_; _impl_.subquery_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Query* RangeTblEntry::unsafe_arena_release_subquery() { // @@protoc_insertion_point(field_release:pg_query.RangeTblEntry.subquery) ::pg_query::Query* temp = _impl_.subquery_; _impl_.subquery_ = nullptr; return temp; } inline ::pg_query::Query* RangeTblEntry::_internal_mutable_subquery() { if (_impl_.subquery_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Query>(GetArenaForAllocation()); _impl_.subquery_ = p; } return _impl_.subquery_; } inline ::pg_query::Query* RangeTblEntry::mutable_subquery() { ::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* subquery) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.subquery_; } if (subquery) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(subquery); if (message_arena != submessage_arena) { subquery = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, subquery, submessage_arena); } } else { } _impl_.subquery_ = subquery; // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTblEntry.subquery) } // bool security_barrier = 7 [json_name = "security_barrier"]; inline void RangeTblEntry::clear_security_barrier() { _impl_.security_barrier_ = false; } inline bool RangeTblEntry::_internal_security_barrier() const { return _impl_.security_barrier_; } inline bool RangeTblEntry::security_barrier() const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.security_barrier) return _internal_security_barrier(); } inline void RangeTblEntry::_internal_set_security_barrier(bool value) { _impl_.security_barrier_ = value; } inline void RangeTblEntry::set_security_barrier(bool value) { _internal_set_security_barrier(value); // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.security_barrier) } // .pg_query.JoinType jointype = 8 [json_name = "jointype"]; inline void RangeTblEntry::clear_jointype() { _impl_.jointype_ = 0; } inline ::pg_query::JoinType RangeTblEntry::_internal_jointype() const { return static_cast< ::pg_query::JoinType >(_impl_.jointype_); } inline ::pg_query::JoinType RangeTblEntry::jointype() const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.jointype) return _internal_jointype(); } inline void RangeTblEntry::_internal_set_jointype(::pg_query::JoinType value) { _impl_.jointype_ = value; } inline void RangeTblEntry::set_jointype(::pg_query::JoinType value) { _internal_set_jointype(value); // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.jointype) } // int32 joinmergedcols = 9 [json_name = "joinmergedcols"]; inline void RangeTblEntry::clear_joinmergedcols() { _impl_.joinmergedcols_ = 0; } inline int32_t RangeTblEntry::_internal_joinmergedcols() const { return _impl_.joinmergedcols_; } inline int32_t RangeTblEntry::joinmergedcols() const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.joinmergedcols) return _internal_joinmergedcols(); } inline void RangeTblEntry::_internal_set_joinmergedcols(int32_t value) { _impl_.joinmergedcols_ = value; } inline void RangeTblEntry::set_joinmergedcols(int32_t value) { _internal_set_joinmergedcols(value); // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.joinmergedcols) } // repeated .pg_query.Node joinaliasvars = 10 [json_name = "joinaliasvars"]; inline int RangeTblEntry::_internal_joinaliasvars_size() const { return _impl_.joinaliasvars_.size(); } inline int RangeTblEntry::joinaliasvars_size() const { return _internal_joinaliasvars_size(); } inline void RangeTblEntry::clear_joinaliasvars() { _impl_.joinaliasvars_.Clear(); } inline ::pg_query::Node* RangeTblEntry::mutable_joinaliasvars(int index) { // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.joinaliasvars) return _impl_.joinaliasvars_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* RangeTblEntry::mutable_joinaliasvars() { // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.joinaliasvars) return &_impl_.joinaliasvars_; } inline const ::pg_query::Node& RangeTblEntry::_internal_joinaliasvars(int index) const { return _impl_.joinaliasvars_.Get(index); } inline const ::pg_query::Node& RangeTblEntry::joinaliasvars(int index) const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.joinaliasvars) return _internal_joinaliasvars(index); } inline ::pg_query::Node* RangeTblEntry::_internal_add_joinaliasvars() { return _impl_.joinaliasvars_.Add(); } inline ::pg_query::Node* RangeTblEntry::add_joinaliasvars() { ::pg_query::Node* _add = _internal_add_joinaliasvars(); // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.joinaliasvars) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& RangeTblEntry::joinaliasvars() const { // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.joinaliasvars) return _impl_.joinaliasvars_; } // repeated .pg_query.Node joinleftcols = 11 [json_name = "joinleftcols"]; inline int RangeTblEntry::_internal_joinleftcols_size() const { return _impl_.joinleftcols_.size(); } inline int RangeTblEntry::joinleftcols_size() const { return _internal_joinleftcols_size(); } inline void RangeTblEntry::clear_joinleftcols() { _impl_.joinleftcols_.Clear(); } inline ::pg_query::Node* RangeTblEntry::mutable_joinleftcols(int index) { // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.joinleftcols) return _impl_.joinleftcols_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* RangeTblEntry::mutable_joinleftcols() { // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.joinleftcols) return &_impl_.joinleftcols_; } inline const ::pg_query::Node& RangeTblEntry::_internal_joinleftcols(int index) const { return _impl_.joinleftcols_.Get(index); } inline const ::pg_query::Node& RangeTblEntry::joinleftcols(int index) const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.joinleftcols) return _internal_joinleftcols(index); } inline ::pg_query::Node* RangeTblEntry::_internal_add_joinleftcols() { return _impl_.joinleftcols_.Add(); } inline ::pg_query::Node* RangeTblEntry::add_joinleftcols() { ::pg_query::Node* _add = _internal_add_joinleftcols(); // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.joinleftcols) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& RangeTblEntry::joinleftcols() const { // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.joinleftcols) return _impl_.joinleftcols_; } // repeated .pg_query.Node joinrightcols = 12 [json_name = "joinrightcols"]; inline int RangeTblEntry::_internal_joinrightcols_size() const { return _impl_.joinrightcols_.size(); } inline int RangeTblEntry::joinrightcols_size() const { return _internal_joinrightcols_size(); } inline void RangeTblEntry::clear_joinrightcols() { _impl_.joinrightcols_.Clear(); } inline ::pg_query::Node* RangeTblEntry::mutable_joinrightcols(int index) { // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.joinrightcols) return _impl_.joinrightcols_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* RangeTblEntry::mutable_joinrightcols() { // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.joinrightcols) return &_impl_.joinrightcols_; } inline const ::pg_query::Node& RangeTblEntry::_internal_joinrightcols(int index) const { return _impl_.joinrightcols_.Get(index); } inline const ::pg_query::Node& RangeTblEntry::joinrightcols(int index) const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.joinrightcols) return _internal_joinrightcols(index); } inline ::pg_query::Node* RangeTblEntry::_internal_add_joinrightcols() { return _impl_.joinrightcols_.Add(); } inline ::pg_query::Node* RangeTblEntry::add_joinrightcols() { ::pg_query::Node* _add = _internal_add_joinrightcols(); // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.joinrightcols) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& RangeTblEntry::joinrightcols() const { // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.joinrightcols) return _impl_.joinrightcols_; } // .pg_query.Alias join_using_alias = 13 [json_name = "join_using_alias"]; inline bool RangeTblEntry::_internal_has_join_using_alias() const { return this != internal_default_instance() && _impl_.join_using_alias_ != nullptr; } inline bool RangeTblEntry::has_join_using_alias() const { return _internal_has_join_using_alias(); } inline void RangeTblEntry::clear_join_using_alias() { if (GetArenaForAllocation() == nullptr && _impl_.join_using_alias_ != nullptr) { delete _impl_.join_using_alias_; } _impl_.join_using_alias_ = nullptr; } inline const ::pg_query::Alias& RangeTblEntry::_internal_join_using_alias() const { const ::pg_query::Alias* p = _impl_.join_using_alias_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Alias_default_instance_); } inline const ::pg_query::Alias& RangeTblEntry::join_using_alias() const { // @@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* join_using_alias) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.join_using_alias_); } _impl_.join_using_alias_ = join_using_alias; if (join_using_alias) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTblEntry.join_using_alias) } inline ::pg_query::Alias* RangeTblEntry::release_join_using_alias() { ::pg_query::Alias* temp = _impl_.join_using_alias_; _impl_.join_using_alias_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Alias* RangeTblEntry::unsafe_arena_release_join_using_alias() { // @@protoc_insertion_point(field_release:pg_query.RangeTblEntry.join_using_alias) ::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() { if (_impl_.join_using_alias_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Alias>(GetArenaForAllocation()); _impl_.join_using_alias_ = p; } return _impl_.join_using_alias_; } inline ::pg_query::Alias* RangeTblEntry::mutable_join_using_alias() { ::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* join_using_alias) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.join_using_alias_; } if (join_using_alias) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(join_using_alias); if (message_arena != submessage_arena) { join_using_alias = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, join_using_alias, submessage_arena); } } else { } _impl_.join_using_alias_ = join_using_alias; // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTblEntry.join_using_alias) } // repeated .pg_query.Node functions = 14 [json_name = "functions"]; inline int RangeTblEntry::_internal_functions_size() const { return _impl_.functions_.size(); } inline int RangeTblEntry::functions_size() const { return _internal_functions_size(); } inline void RangeTblEntry::clear_functions() { _impl_.functions_.Clear(); } inline ::pg_query::Node* RangeTblEntry::mutable_functions(int index) { // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.functions) return _impl_.functions_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* RangeTblEntry::mutable_functions() { // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.functions) return &_impl_.functions_; } inline const ::pg_query::Node& RangeTblEntry::_internal_functions(int index) const { return _impl_.functions_.Get(index); } inline const ::pg_query::Node& RangeTblEntry::functions(int index) const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.functions) return _internal_functions(index); } inline ::pg_query::Node* RangeTblEntry::_internal_add_functions() { return _impl_.functions_.Add(); } inline ::pg_query::Node* RangeTblEntry::add_functions() { ::pg_query::Node* _add = _internal_add_functions(); // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.functions) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& RangeTblEntry::functions() const { // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.functions) return _impl_.functions_; } // bool funcordinality = 15 [json_name = "funcordinality"]; inline void RangeTblEntry::clear_funcordinality() { _impl_.funcordinality_ = false; } inline bool RangeTblEntry::_internal_funcordinality() const { return _impl_.funcordinality_; } inline bool RangeTblEntry::funcordinality() const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.funcordinality) return _internal_funcordinality(); } inline void RangeTblEntry::_internal_set_funcordinality(bool value) { _impl_.funcordinality_ = value; } inline void RangeTblEntry::set_funcordinality(bool value) { _internal_set_funcordinality(value); // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.funcordinality) } // .pg_query.TableFunc tablefunc = 16 [json_name = "tablefunc"]; inline bool RangeTblEntry::_internal_has_tablefunc() const { return this != internal_default_instance() && _impl_.tablefunc_ != nullptr; } inline bool RangeTblEntry::has_tablefunc() const { return _internal_has_tablefunc(); } inline void RangeTblEntry::clear_tablefunc() { if (GetArenaForAllocation() == nullptr && _impl_.tablefunc_ != nullptr) { delete _impl_.tablefunc_; } _impl_.tablefunc_ = nullptr; } inline const ::pg_query::TableFunc& RangeTblEntry::_internal_tablefunc() const { const ::pg_query::TableFunc* p = _impl_.tablefunc_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_TableFunc_default_instance_); } inline const ::pg_query::TableFunc& RangeTblEntry::tablefunc() const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.tablefunc) return _internal_tablefunc(); } inline void RangeTblEntry::unsafe_arena_set_allocated_tablefunc( ::pg_query::TableFunc* tablefunc) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tablefunc_); } _impl_.tablefunc_ = tablefunc; if (tablefunc) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTblEntry.tablefunc) } inline ::pg_query::TableFunc* RangeTblEntry::release_tablefunc() { ::pg_query::TableFunc* temp = _impl_.tablefunc_; _impl_.tablefunc_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::TableFunc* RangeTblEntry::unsafe_arena_release_tablefunc() { // @@protoc_insertion_point(field_release:pg_query.RangeTblEntry.tablefunc) ::pg_query::TableFunc* temp = _impl_.tablefunc_; _impl_.tablefunc_ = nullptr; return temp; } inline ::pg_query::TableFunc* RangeTblEntry::_internal_mutable_tablefunc() { if (_impl_.tablefunc_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::TableFunc>(GetArenaForAllocation()); _impl_.tablefunc_ = p; } return _impl_.tablefunc_; } inline ::pg_query::TableFunc* RangeTblEntry::mutable_tablefunc() { ::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* tablefunc) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.tablefunc_; } if (tablefunc) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(tablefunc); if (message_arena != submessage_arena) { tablefunc = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, tablefunc, submessage_arena); } } else { } _impl_.tablefunc_ = tablefunc; // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTblEntry.tablefunc) } // repeated .pg_query.Node values_lists = 17 [json_name = "values_lists"]; inline int RangeTblEntry::_internal_values_lists_size() const { return _impl_.values_lists_.size(); } inline int RangeTblEntry::values_lists_size() const { return _internal_values_lists_size(); } inline void RangeTblEntry::clear_values_lists() { _impl_.values_lists_.Clear(); } inline ::pg_query::Node* RangeTblEntry::mutable_values_lists(int index) { // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.values_lists) return _impl_.values_lists_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* RangeTblEntry::mutable_values_lists() { // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.values_lists) return &_impl_.values_lists_; } inline const ::pg_query::Node& RangeTblEntry::_internal_values_lists(int index) const { return _impl_.values_lists_.Get(index); } inline const ::pg_query::Node& RangeTblEntry::values_lists(int index) const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.values_lists) return _internal_values_lists(index); } inline ::pg_query::Node* RangeTblEntry::_internal_add_values_lists() { return _impl_.values_lists_.Add(); } inline ::pg_query::Node* RangeTblEntry::add_values_lists() { ::pg_query::Node* _add = _internal_add_values_lists(); // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.values_lists) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& RangeTblEntry::values_lists() const { // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.values_lists) return _impl_.values_lists_; } // string ctename = 18 [json_name = "ctename"]; inline void RangeTblEntry::clear_ctename() { _impl_.ctename_.ClearToEmpty(); } inline const std::string& RangeTblEntry::ctename() const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.ctename) return _internal_ctename(); } template inline PROTOBUF_ALWAYS_INLINE void RangeTblEntry::set_ctename(ArgT0&& arg0, ArgT... args) { _impl_.ctename_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.ctename) } inline std::string* RangeTblEntry::mutable_ctename() { 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 { return _impl_.ctename_.Get(); } inline void RangeTblEntry::_internal_set_ctename(const std::string& value) { _impl_.ctename_.Set(value, GetArenaForAllocation()); } inline std::string* RangeTblEntry::_internal_mutable_ctename() { return _impl_.ctename_.Mutable(GetArenaForAllocation()); } inline std::string* RangeTblEntry::release_ctename() { // @@protoc_insertion_point(field_release:pg_query.RangeTblEntry.ctename) return _impl_.ctename_.Release(); } inline void RangeTblEntry::set_allocated_ctename(std::string* ctename) { if (ctename != nullptr) { } else { } _impl_.ctename_.SetAllocated(ctename, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.ctename_.IsDefault()) { _impl_.ctename_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTblEntry.ctename) } // uint32 ctelevelsup = 19 [json_name = "ctelevelsup"]; inline void RangeTblEntry::clear_ctelevelsup() { _impl_.ctelevelsup_ = 0u; } inline uint32_t RangeTblEntry::_internal_ctelevelsup() const { return _impl_.ctelevelsup_; } inline uint32_t RangeTblEntry::ctelevelsup() const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.ctelevelsup) return _internal_ctelevelsup(); } inline void RangeTblEntry::_internal_set_ctelevelsup(uint32_t value) { _impl_.ctelevelsup_ = value; } inline void RangeTblEntry::set_ctelevelsup(uint32_t value) { _internal_set_ctelevelsup(value); // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.ctelevelsup) } // bool self_reference = 20 [json_name = "self_reference"]; inline void RangeTblEntry::clear_self_reference() { _impl_.self_reference_ = false; } inline bool RangeTblEntry::_internal_self_reference() const { return _impl_.self_reference_; } inline bool RangeTblEntry::self_reference() const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.self_reference) return _internal_self_reference(); } inline void RangeTblEntry::_internal_set_self_reference(bool value) { _impl_.self_reference_ = value; } inline void RangeTblEntry::set_self_reference(bool value) { _internal_set_self_reference(value); // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.self_reference) } // repeated .pg_query.Node coltypes = 21 [json_name = "coltypes"]; inline int RangeTblEntry::_internal_coltypes_size() const { return _impl_.coltypes_.size(); } inline int RangeTblEntry::coltypes_size() const { return _internal_coltypes_size(); } inline void RangeTblEntry::clear_coltypes() { _impl_.coltypes_.Clear(); } inline ::pg_query::Node* RangeTblEntry::mutable_coltypes(int index) { // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.coltypes) return _impl_.coltypes_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* RangeTblEntry::mutable_coltypes() { // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.coltypes) return &_impl_.coltypes_; } inline const ::pg_query::Node& RangeTblEntry::_internal_coltypes(int index) const { return _impl_.coltypes_.Get(index); } inline const ::pg_query::Node& RangeTblEntry::coltypes(int index) const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.coltypes) return _internal_coltypes(index); } inline ::pg_query::Node* RangeTblEntry::_internal_add_coltypes() { return _impl_.coltypes_.Add(); } inline ::pg_query::Node* RangeTblEntry::add_coltypes() { ::pg_query::Node* _add = _internal_add_coltypes(); // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.coltypes) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& RangeTblEntry::coltypes() const { // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.coltypes) return _impl_.coltypes_; } // repeated .pg_query.Node coltypmods = 22 [json_name = "coltypmods"]; inline int RangeTblEntry::_internal_coltypmods_size() const { return _impl_.coltypmods_.size(); } inline int RangeTblEntry::coltypmods_size() const { return _internal_coltypmods_size(); } inline void RangeTblEntry::clear_coltypmods() { _impl_.coltypmods_.Clear(); } inline ::pg_query::Node* RangeTblEntry::mutable_coltypmods(int index) { // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.coltypmods) return _impl_.coltypmods_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* RangeTblEntry::mutable_coltypmods() { // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.coltypmods) return &_impl_.coltypmods_; } inline const ::pg_query::Node& RangeTblEntry::_internal_coltypmods(int index) const { return _impl_.coltypmods_.Get(index); } inline const ::pg_query::Node& RangeTblEntry::coltypmods(int index) const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.coltypmods) return _internal_coltypmods(index); } inline ::pg_query::Node* RangeTblEntry::_internal_add_coltypmods() { return _impl_.coltypmods_.Add(); } inline ::pg_query::Node* RangeTblEntry::add_coltypmods() { ::pg_query::Node* _add = _internal_add_coltypmods(); // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.coltypmods) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& RangeTblEntry::coltypmods() const { // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.coltypmods) return _impl_.coltypmods_; } // repeated .pg_query.Node colcollations = 23 [json_name = "colcollations"]; inline int RangeTblEntry::_internal_colcollations_size() const { return _impl_.colcollations_.size(); } inline int RangeTblEntry::colcollations_size() const { return _internal_colcollations_size(); } inline void RangeTblEntry::clear_colcollations() { _impl_.colcollations_.Clear(); } inline ::pg_query::Node* RangeTblEntry::mutable_colcollations(int index) { // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.colcollations) return _impl_.colcollations_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* RangeTblEntry::mutable_colcollations() { // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.colcollations) return &_impl_.colcollations_; } inline const ::pg_query::Node& RangeTblEntry::_internal_colcollations(int index) const { return _impl_.colcollations_.Get(index); } inline const ::pg_query::Node& RangeTblEntry::colcollations(int index) const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.colcollations) return _internal_colcollations(index); } inline ::pg_query::Node* RangeTblEntry::_internal_add_colcollations() { return _impl_.colcollations_.Add(); } inline ::pg_query::Node* RangeTblEntry::add_colcollations() { ::pg_query::Node* _add = _internal_add_colcollations(); // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.colcollations) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& RangeTblEntry::colcollations() const { // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.colcollations) return _impl_.colcollations_; } // string enrname = 24 [json_name = "enrname"]; inline void RangeTblEntry::clear_enrname() { _impl_.enrname_.ClearToEmpty(); } inline const std::string& RangeTblEntry::enrname() const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.enrname) return _internal_enrname(); } template inline PROTOBUF_ALWAYS_INLINE void RangeTblEntry::set_enrname(ArgT0&& arg0, ArgT... args) { _impl_.enrname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.enrname) } inline std::string* RangeTblEntry::mutable_enrname() { 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 { return _impl_.enrname_.Get(); } inline void RangeTblEntry::_internal_set_enrname(const std::string& value) { _impl_.enrname_.Set(value, GetArenaForAllocation()); } inline std::string* RangeTblEntry::_internal_mutable_enrname() { return _impl_.enrname_.Mutable(GetArenaForAllocation()); } inline std::string* RangeTblEntry::release_enrname() { // @@protoc_insertion_point(field_release:pg_query.RangeTblEntry.enrname) return _impl_.enrname_.Release(); } inline void RangeTblEntry::set_allocated_enrname(std::string* enrname) { if (enrname != nullptr) { } else { } _impl_.enrname_.SetAllocated(enrname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.enrname_.IsDefault()) { _impl_.enrname_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTblEntry.enrname) } // double enrtuples = 25 [json_name = "enrtuples"]; inline void RangeTblEntry::clear_enrtuples() { _impl_.enrtuples_ = 0; } inline double RangeTblEntry::_internal_enrtuples() const { return _impl_.enrtuples_; } inline double RangeTblEntry::enrtuples() const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.enrtuples) return _internal_enrtuples(); } inline void RangeTblEntry::_internal_set_enrtuples(double value) { _impl_.enrtuples_ = value; } inline void RangeTblEntry::set_enrtuples(double value) { _internal_set_enrtuples(value); // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.enrtuples) } // .pg_query.Alias alias = 26 [json_name = "alias"]; inline bool RangeTblEntry::_internal_has_alias() const { return this != internal_default_instance() && _impl_.alias_ != nullptr; } inline bool RangeTblEntry::has_alias() const { return _internal_has_alias(); } inline void RangeTblEntry::clear_alias() { if (GetArenaForAllocation() == nullptr && _impl_.alias_ != nullptr) { delete _impl_.alias_; } _impl_.alias_ = nullptr; } inline const ::pg_query::Alias& RangeTblEntry::_internal_alias() const { const ::pg_query::Alias* p = _impl_.alias_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Alias_default_instance_); } inline const ::pg_query::Alias& RangeTblEntry::alias() const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.alias) return _internal_alias(); } inline void RangeTblEntry::unsafe_arena_set_allocated_alias( ::pg_query::Alias* alias) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.alias_); } _impl_.alias_ = alias; if (alias) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTblEntry.alias) } inline ::pg_query::Alias* RangeTblEntry::release_alias() { ::pg_query::Alias* temp = _impl_.alias_; _impl_.alias_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Alias* RangeTblEntry::unsafe_arena_release_alias() { // @@protoc_insertion_point(field_release:pg_query.RangeTblEntry.alias) ::pg_query::Alias* temp = _impl_.alias_; _impl_.alias_ = nullptr; return temp; } inline ::pg_query::Alias* RangeTblEntry::_internal_mutable_alias() { if (_impl_.alias_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Alias>(GetArenaForAllocation()); _impl_.alias_ = p; } return _impl_.alias_; } inline ::pg_query::Alias* RangeTblEntry::mutable_alias() { ::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* alias) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.alias_; } if (alias) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(alias); if (message_arena != submessage_arena) { alias = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, alias, submessage_arena); } } else { } _impl_.alias_ = alias; // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTblEntry.alias) } // .pg_query.Alias eref = 27 [json_name = "eref"]; inline bool RangeTblEntry::_internal_has_eref() const { return this != internal_default_instance() && _impl_.eref_ != nullptr; } inline bool RangeTblEntry::has_eref() const { return _internal_has_eref(); } inline void RangeTblEntry::clear_eref() { if (GetArenaForAllocation() == nullptr && _impl_.eref_ != nullptr) { delete _impl_.eref_; } _impl_.eref_ = nullptr; } inline const ::pg_query::Alias& RangeTblEntry::_internal_eref() const { const ::pg_query::Alias* p = _impl_.eref_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Alias_default_instance_); } inline const ::pg_query::Alias& RangeTblEntry::eref() const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.eref) return _internal_eref(); } inline void RangeTblEntry::unsafe_arena_set_allocated_eref( ::pg_query::Alias* eref) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.eref_); } _impl_.eref_ = eref; if (eref) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTblEntry.eref) } inline ::pg_query::Alias* RangeTblEntry::release_eref() { ::pg_query::Alias* temp = _impl_.eref_; _impl_.eref_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Alias* RangeTblEntry::unsafe_arena_release_eref() { // @@protoc_insertion_point(field_release:pg_query.RangeTblEntry.eref) ::pg_query::Alias* temp = _impl_.eref_; _impl_.eref_ = nullptr; return temp; } inline ::pg_query::Alias* RangeTblEntry::_internal_mutable_eref() { if (_impl_.eref_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Alias>(GetArenaForAllocation()); _impl_.eref_ = p; } return _impl_.eref_; } inline ::pg_query::Alias* RangeTblEntry::mutable_eref() { ::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* eref) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.eref_; } if (eref) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(eref); if (message_arena != submessage_arena) { eref = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, eref, submessage_arena); } } else { } _impl_.eref_ = eref; // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTblEntry.eref) } // bool lateral = 28 [json_name = "lateral"]; inline void RangeTblEntry::clear_lateral() { _impl_.lateral_ = false; } inline bool RangeTblEntry::_internal_lateral() const { return _impl_.lateral_; } inline bool RangeTblEntry::lateral() const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.lateral) return _internal_lateral(); } inline void RangeTblEntry::_internal_set_lateral(bool value) { _impl_.lateral_ = value; } inline void RangeTblEntry::set_lateral(bool value) { _internal_set_lateral(value); // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.lateral) } // bool inh = 29 [json_name = "inh"]; inline void RangeTblEntry::clear_inh() { _impl_.inh_ = false; } inline bool RangeTblEntry::_internal_inh() const { return _impl_.inh_; } inline bool RangeTblEntry::inh() const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.inh) return _internal_inh(); } inline void RangeTblEntry::_internal_set_inh(bool value) { _impl_.inh_ = value; } inline void RangeTblEntry::set_inh(bool value) { _internal_set_inh(value); // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.inh) } // bool in_from_cl = 30 [json_name = "inFromCl"]; inline void RangeTblEntry::clear_in_from_cl() { _impl_.in_from_cl_ = false; } inline bool RangeTblEntry::_internal_in_from_cl() const { return _impl_.in_from_cl_; } inline bool RangeTblEntry::in_from_cl() const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.in_from_cl) return _internal_in_from_cl(); } inline void RangeTblEntry::_internal_set_in_from_cl(bool value) { _impl_.in_from_cl_ = value; } inline void RangeTblEntry::set_in_from_cl(bool value) { _internal_set_in_from_cl(value); // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.in_from_cl) } // uint32 required_perms = 31 [json_name = "requiredPerms"]; inline void RangeTblEntry::clear_required_perms() { _impl_.required_perms_ = 0u; } inline uint32_t RangeTblEntry::_internal_required_perms() const { return _impl_.required_perms_; } inline uint32_t RangeTblEntry::required_perms() const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.required_perms) return _internal_required_perms(); } inline void RangeTblEntry::_internal_set_required_perms(uint32_t value) { _impl_.required_perms_ = value; } inline void RangeTblEntry::set_required_perms(uint32_t value) { _internal_set_required_perms(value); // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.required_perms) } // uint32 check_as_user = 32 [json_name = "checkAsUser"]; inline void RangeTblEntry::clear_check_as_user() { _impl_.check_as_user_ = 0u; } inline uint32_t RangeTblEntry::_internal_check_as_user() const { return _impl_.check_as_user_; } inline uint32_t RangeTblEntry::check_as_user() const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.check_as_user) return _internal_check_as_user(); } inline void RangeTblEntry::_internal_set_check_as_user(uint32_t value) { _impl_.check_as_user_ = value; } inline void RangeTblEntry::set_check_as_user(uint32_t value) { _internal_set_check_as_user(value); // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.check_as_user) } // repeated uint64 selected_cols = 33 [json_name = "selectedCols"]; inline int RangeTblEntry::_internal_selected_cols_size() const { return _impl_.selected_cols_.size(); } inline int RangeTblEntry::selected_cols_size() const { return _internal_selected_cols_size(); } inline void RangeTblEntry::clear_selected_cols() { _impl_.selected_cols_.Clear(); } inline uint64_t RangeTblEntry::_internal_selected_cols(int index) const { return _impl_.selected_cols_.Get(index); } inline uint64_t RangeTblEntry::selected_cols(int index) const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.selected_cols) return _internal_selected_cols(index); } inline void RangeTblEntry::set_selected_cols(int index, uint64_t value) { _impl_.selected_cols_.Set(index, value); // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.selected_cols) } inline void RangeTblEntry::_internal_add_selected_cols(uint64_t value) { _impl_.selected_cols_.Add(value); } inline void RangeTblEntry::add_selected_cols(uint64_t value) { _internal_add_selected_cols(value); // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.selected_cols) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >& RangeTblEntry::_internal_selected_cols() const { return _impl_.selected_cols_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >& RangeTblEntry::selected_cols() const { // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.selected_cols) return _internal_selected_cols(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >* RangeTblEntry::_internal_mutable_selected_cols() { return &_impl_.selected_cols_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >* RangeTblEntry::mutable_selected_cols() { // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.selected_cols) return _internal_mutable_selected_cols(); } // repeated uint64 inserted_cols = 34 [json_name = "insertedCols"]; inline int RangeTblEntry::_internal_inserted_cols_size() const { return _impl_.inserted_cols_.size(); } inline int RangeTblEntry::inserted_cols_size() const { return _internal_inserted_cols_size(); } inline void RangeTblEntry::clear_inserted_cols() { _impl_.inserted_cols_.Clear(); } inline uint64_t RangeTblEntry::_internal_inserted_cols(int index) const { return _impl_.inserted_cols_.Get(index); } inline uint64_t RangeTblEntry::inserted_cols(int index) const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.inserted_cols) return _internal_inserted_cols(index); } inline void RangeTblEntry::set_inserted_cols(int index, uint64_t value) { _impl_.inserted_cols_.Set(index, value); // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.inserted_cols) } inline void RangeTblEntry::_internal_add_inserted_cols(uint64_t value) { _impl_.inserted_cols_.Add(value); } inline void RangeTblEntry::add_inserted_cols(uint64_t value) { _internal_add_inserted_cols(value); // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.inserted_cols) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >& RangeTblEntry::_internal_inserted_cols() const { return _impl_.inserted_cols_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >& RangeTblEntry::inserted_cols() const { // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.inserted_cols) return _internal_inserted_cols(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >* RangeTblEntry::_internal_mutable_inserted_cols() { return &_impl_.inserted_cols_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >* RangeTblEntry::mutable_inserted_cols() { // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.inserted_cols) return _internal_mutable_inserted_cols(); } // repeated uint64 updated_cols = 35 [json_name = "updatedCols"]; inline int RangeTblEntry::_internal_updated_cols_size() const { return _impl_.updated_cols_.size(); } inline int RangeTblEntry::updated_cols_size() const { return _internal_updated_cols_size(); } inline void RangeTblEntry::clear_updated_cols() { _impl_.updated_cols_.Clear(); } inline uint64_t RangeTblEntry::_internal_updated_cols(int index) const { return _impl_.updated_cols_.Get(index); } inline uint64_t RangeTblEntry::updated_cols(int index) const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.updated_cols) return _internal_updated_cols(index); } inline void RangeTblEntry::set_updated_cols(int index, uint64_t value) { _impl_.updated_cols_.Set(index, value); // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.updated_cols) } inline void RangeTblEntry::_internal_add_updated_cols(uint64_t value) { _impl_.updated_cols_.Add(value); } inline void RangeTblEntry::add_updated_cols(uint64_t value) { _internal_add_updated_cols(value); // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.updated_cols) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >& RangeTblEntry::_internal_updated_cols() const { return _impl_.updated_cols_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >& RangeTblEntry::updated_cols() const { // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.updated_cols) return _internal_updated_cols(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >* RangeTblEntry::_internal_mutable_updated_cols() { return &_impl_.updated_cols_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >* RangeTblEntry::mutable_updated_cols() { // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.updated_cols) return _internal_mutable_updated_cols(); } // repeated uint64 extra_updated_cols = 36 [json_name = "extraUpdatedCols"]; inline int RangeTblEntry::_internal_extra_updated_cols_size() const { return _impl_.extra_updated_cols_.size(); } inline int RangeTblEntry::extra_updated_cols_size() const { return _internal_extra_updated_cols_size(); } inline void RangeTblEntry::clear_extra_updated_cols() { _impl_.extra_updated_cols_.Clear(); } inline uint64_t RangeTblEntry::_internal_extra_updated_cols(int index) const { return _impl_.extra_updated_cols_.Get(index); } inline uint64_t RangeTblEntry::extra_updated_cols(int index) const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.extra_updated_cols) return _internal_extra_updated_cols(index); } inline void RangeTblEntry::set_extra_updated_cols(int index, uint64_t value) { _impl_.extra_updated_cols_.Set(index, value); // @@protoc_insertion_point(field_set:pg_query.RangeTblEntry.extra_updated_cols) } inline void RangeTblEntry::_internal_add_extra_updated_cols(uint64_t value) { _impl_.extra_updated_cols_.Add(value); } inline void RangeTblEntry::add_extra_updated_cols(uint64_t value) { _internal_add_extra_updated_cols(value); // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.extra_updated_cols) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >& RangeTblEntry::_internal_extra_updated_cols() const { return _impl_.extra_updated_cols_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >& RangeTblEntry::extra_updated_cols() const { // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.extra_updated_cols) return _internal_extra_updated_cols(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >* RangeTblEntry::_internal_mutable_extra_updated_cols() { return &_impl_.extra_updated_cols_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >* RangeTblEntry::mutable_extra_updated_cols() { // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.extra_updated_cols) return _internal_mutable_extra_updated_cols(); } // repeated .pg_query.Node security_quals = 37 [json_name = "securityQuals"]; inline int RangeTblEntry::_internal_security_quals_size() const { return _impl_.security_quals_.size(); } inline int RangeTblEntry::security_quals_size() const { return _internal_security_quals_size(); } inline void RangeTblEntry::clear_security_quals() { _impl_.security_quals_.Clear(); } inline ::pg_query::Node* RangeTblEntry::mutable_security_quals(int index) { // @@protoc_insertion_point(field_mutable:pg_query.RangeTblEntry.security_quals) return _impl_.security_quals_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* RangeTblEntry::mutable_security_quals() { // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblEntry.security_quals) return &_impl_.security_quals_; } inline const ::pg_query::Node& RangeTblEntry::_internal_security_quals(int index) const { return _impl_.security_quals_.Get(index); } inline const ::pg_query::Node& RangeTblEntry::security_quals(int index) const { // @@protoc_insertion_point(field_get:pg_query.RangeTblEntry.security_quals) return _internal_security_quals(index); } inline ::pg_query::Node* RangeTblEntry::_internal_add_security_quals() { return _impl_.security_quals_.Add(); } inline ::pg_query::Node* RangeTblEntry::add_security_quals() { ::pg_query::Node* _add = _internal_add_security_quals(); // @@protoc_insertion_point(field_add:pg_query.RangeTblEntry.security_quals) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& RangeTblEntry::security_quals() const { // @@protoc_insertion_point(field_list:pg_query.RangeTblEntry.security_quals) return _impl_.security_quals_; } // ------------------------------------------------------------------- // RangeTblFunction // .pg_query.Node funcexpr = 1 [json_name = "funcexpr"]; inline bool RangeTblFunction::_internal_has_funcexpr() const { return this != internal_default_instance() && _impl_.funcexpr_ != nullptr; } inline bool RangeTblFunction::has_funcexpr() const { return _internal_has_funcexpr(); } inline void RangeTblFunction::clear_funcexpr() { if (GetArenaForAllocation() == nullptr && _impl_.funcexpr_ != nullptr) { delete _impl_.funcexpr_; } _impl_.funcexpr_ = nullptr; } inline const ::pg_query::Node& RangeTblFunction::_internal_funcexpr() const { const ::pg_query::Node* p = _impl_.funcexpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& RangeTblFunction::funcexpr() const { // @@protoc_insertion_point(field_get:pg_query.RangeTblFunction.funcexpr) return _internal_funcexpr(); } inline void RangeTblFunction::unsafe_arena_set_allocated_funcexpr( ::pg_query::Node* funcexpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.funcexpr_); } _impl_.funcexpr_ = funcexpr; if (funcexpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.RangeTblFunction.funcexpr) } inline ::pg_query::Node* RangeTblFunction::release_funcexpr() { ::pg_query::Node* temp = _impl_.funcexpr_; _impl_.funcexpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* RangeTblFunction::unsafe_arena_release_funcexpr() { // @@protoc_insertion_point(field_release:pg_query.RangeTblFunction.funcexpr) ::pg_query::Node* temp = _impl_.funcexpr_; _impl_.funcexpr_ = nullptr; return temp; } inline ::pg_query::Node* RangeTblFunction::_internal_mutable_funcexpr() { if (_impl_.funcexpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.funcexpr_ = p; } return _impl_.funcexpr_; } inline ::pg_query::Node* RangeTblFunction::mutable_funcexpr() { ::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* funcexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.funcexpr_; } if (funcexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(funcexpr); if (message_arena != submessage_arena) { funcexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, funcexpr, submessage_arena); } } else { } _impl_.funcexpr_ = funcexpr; // @@protoc_insertion_point(field_set_allocated:pg_query.RangeTblFunction.funcexpr) } // int32 funccolcount = 2 [json_name = "funccolcount"]; inline void RangeTblFunction::clear_funccolcount() { _impl_.funccolcount_ = 0; } inline int32_t RangeTblFunction::_internal_funccolcount() const { return _impl_.funccolcount_; } inline int32_t RangeTblFunction::funccolcount() const { // @@protoc_insertion_point(field_get:pg_query.RangeTblFunction.funccolcount) return _internal_funccolcount(); } inline void RangeTblFunction::_internal_set_funccolcount(int32_t value) { _impl_.funccolcount_ = value; } inline void RangeTblFunction::set_funccolcount(int32_t value) { _internal_set_funccolcount(value); // @@protoc_insertion_point(field_set:pg_query.RangeTblFunction.funccolcount) } // repeated .pg_query.Node funccolnames = 3 [json_name = "funccolnames"]; inline int RangeTblFunction::_internal_funccolnames_size() const { return _impl_.funccolnames_.size(); } inline int RangeTblFunction::funccolnames_size() const { return _internal_funccolnames_size(); } inline void RangeTblFunction::clear_funccolnames() { _impl_.funccolnames_.Clear(); } inline ::pg_query::Node* RangeTblFunction::mutable_funccolnames(int index) { // @@protoc_insertion_point(field_mutable:pg_query.RangeTblFunction.funccolnames) return _impl_.funccolnames_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* RangeTblFunction::mutable_funccolnames() { // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblFunction.funccolnames) return &_impl_.funccolnames_; } inline const ::pg_query::Node& RangeTblFunction::_internal_funccolnames(int index) const { return _impl_.funccolnames_.Get(index); } inline const ::pg_query::Node& RangeTblFunction::funccolnames(int index) const { // @@protoc_insertion_point(field_get:pg_query.RangeTblFunction.funccolnames) return _internal_funccolnames(index); } inline ::pg_query::Node* RangeTblFunction::_internal_add_funccolnames() { return _impl_.funccolnames_.Add(); } inline ::pg_query::Node* RangeTblFunction::add_funccolnames() { ::pg_query::Node* _add = _internal_add_funccolnames(); // @@protoc_insertion_point(field_add:pg_query.RangeTblFunction.funccolnames) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& RangeTblFunction::funccolnames() const { // @@protoc_insertion_point(field_list:pg_query.RangeTblFunction.funccolnames) return _impl_.funccolnames_; } // repeated .pg_query.Node funccoltypes = 4 [json_name = "funccoltypes"]; inline int RangeTblFunction::_internal_funccoltypes_size() const { return _impl_.funccoltypes_.size(); } inline int RangeTblFunction::funccoltypes_size() const { return _internal_funccoltypes_size(); } inline void RangeTblFunction::clear_funccoltypes() { _impl_.funccoltypes_.Clear(); } inline ::pg_query::Node* RangeTblFunction::mutable_funccoltypes(int index) { // @@protoc_insertion_point(field_mutable:pg_query.RangeTblFunction.funccoltypes) return _impl_.funccoltypes_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* RangeTblFunction::mutable_funccoltypes() { // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblFunction.funccoltypes) return &_impl_.funccoltypes_; } inline const ::pg_query::Node& RangeTblFunction::_internal_funccoltypes(int index) const { return _impl_.funccoltypes_.Get(index); } inline const ::pg_query::Node& RangeTblFunction::funccoltypes(int index) const { // @@protoc_insertion_point(field_get:pg_query.RangeTblFunction.funccoltypes) return _internal_funccoltypes(index); } inline ::pg_query::Node* RangeTblFunction::_internal_add_funccoltypes() { return _impl_.funccoltypes_.Add(); } inline ::pg_query::Node* RangeTblFunction::add_funccoltypes() { ::pg_query::Node* _add = _internal_add_funccoltypes(); // @@protoc_insertion_point(field_add:pg_query.RangeTblFunction.funccoltypes) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& RangeTblFunction::funccoltypes() const { // @@protoc_insertion_point(field_list:pg_query.RangeTblFunction.funccoltypes) return _impl_.funccoltypes_; } // repeated .pg_query.Node funccoltypmods = 5 [json_name = "funccoltypmods"]; inline int RangeTblFunction::_internal_funccoltypmods_size() const { return _impl_.funccoltypmods_.size(); } inline int RangeTblFunction::funccoltypmods_size() const { return _internal_funccoltypmods_size(); } inline void RangeTblFunction::clear_funccoltypmods() { _impl_.funccoltypmods_.Clear(); } inline ::pg_query::Node* RangeTblFunction::mutable_funccoltypmods(int index) { // @@protoc_insertion_point(field_mutable:pg_query.RangeTblFunction.funccoltypmods) return _impl_.funccoltypmods_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* RangeTblFunction::mutable_funccoltypmods() { // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblFunction.funccoltypmods) return &_impl_.funccoltypmods_; } inline const ::pg_query::Node& RangeTblFunction::_internal_funccoltypmods(int index) const { return _impl_.funccoltypmods_.Get(index); } inline const ::pg_query::Node& RangeTblFunction::funccoltypmods(int index) const { // @@protoc_insertion_point(field_get:pg_query.RangeTblFunction.funccoltypmods) return _internal_funccoltypmods(index); } inline ::pg_query::Node* RangeTblFunction::_internal_add_funccoltypmods() { return _impl_.funccoltypmods_.Add(); } inline ::pg_query::Node* RangeTblFunction::add_funccoltypmods() { ::pg_query::Node* _add = _internal_add_funccoltypmods(); // @@protoc_insertion_point(field_add:pg_query.RangeTblFunction.funccoltypmods) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& RangeTblFunction::funccoltypmods() const { // @@protoc_insertion_point(field_list:pg_query.RangeTblFunction.funccoltypmods) return _impl_.funccoltypmods_; } // repeated .pg_query.Node funccolcollations = 6 [json_name = "funccolcollations"]; inline int RangeTblFunction::_internal_funccolcollations_size() const { return _impl_.funccolcollations_.size(); } inline int RangeTblFunction::funccolcollations_size() const { return _internal_funccolcollations_size(); } inline void RangeTblFunction::clear_funccolcollations() { _impl_.funccolcollations_.Clear(); } inline ::pg_query::Node* RangeTblFunction::mutable_funccolcollations(int index) { // @@protoc_insertion_point(field_mutable:pg_query.RangeTblFunction.funccolcollations) return _impl_.funccolcollations_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* RangeTblFunction::mutable_funccolcollations() { // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblFunction.funccolcollations) return &_impl_.funccolcollations_; } inline const ::pg_query::Node& RangeTblFunction::_internal_funccolcollations(int index) const { return _impl_.funccolcollations_.Get(index); } inline const ::pg_query::Node& RangeTblFunction::funccolcollations(int index) const { // @@protoc_insertion_point(field_get:pg_query.RangeTblFunction.funccolcollations) return _internal_funccolcollations(index); } inline ::pg_query::Node* RangeTblFunction::_internal_add_funccolcollations() { return _impl_.funccolcollations_.Add(); } inline ::pg_query::Node* RangeTblFunction::add_funccolcollations() { ::pg_query::Node* _add = _internal_add_funccolcollations(); // @@protoc_insertion_point(field_add:pg_query.RangeTblFunction.funccolcollations) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& RangeTblFunction::funccolcollations() const { // @@protoc_insertion_point(field_list:pg_query.RangeTblFunction.funccolcollations) return _impl_.funccolcollations_; } // repeated uint64 funcparams = 7 [json_name = "funcparams"]; inline int RangeTblFunction::_internal_funcparams_size() const { return _impl_.funcparams_.size(); } inline int RangeTblFunction::funcparams_size() const { return _internal_funcparams_size(); } inline void RangeTblFunction::clear_funcparams() { _impl_.funcparams_.Clear(); } inline uint64_t RangeTblFunction::_internal_funcparams(int index) const { return _impl_.funcparams_.Get(index); } inline uint64_t RangeTblFunction::funcparams(int index) const { // @@protoc_insertion_point(field_get:pg_query.RangeTblFunction.funcparams) return _internal_funcparams(index); } inline void RangeTblFunction::set_funcparams(int index, uint64_t value) { _impl_.funcparams_.Set(index, value); // @@protoc_insertion_point(field_set:pg_query.RangeTblFunction.funcparams) } inline void RangeTblFunction::_internal_add_funcparams(uint64_t value) { _impl_.funcparams_.Add(value); } inline void RangeTblFunction::add_funcparams(uint64_t value) { _internal_add_funcparams(value); // @@protoc_insertion_point(field_add:pg_query.RangeTblFunction.funcparams) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >& RangeTblFunction::_internal_funcparams() const { return _impl_.funcparams_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >& RangeTblFunction::funcparams() const { // @@protoc_insertion_point(field_list:pg_query.RangeTblFunction.funcparams) return _internal_funcparams(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >* RangeTblFunction::_internal_mutable_funcparams() { return &_impl_.funcparams_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >* RangeTblFunction::mutable_funcparams() { // @@protoc_insertion_point(field_mutable_list:pg_query.RangeTblFunction.funcparams) return _internal_mutable_funcparams(); } // ------------------------------------------------------------------- // TableSampleClause // uint32 tsmhandler = 1 [json_name = "tsmhandler"]; inline void TableSampleClause::clear_tsmhandler() { _impl_.tsmhandler_ = 0u; } inline uint32_t TableSampleClause::_internal_tsmhandler() const { return _impl_.tsmhandler_; } inline uint32_t TableSampleClause::tsmhandler() const { // @@protoc_insertion_point(field_get:pg_query.TableSampleClause.tsmhandler) return _internal_tsmhandler(); } inline void TableSampleClause::_internal_set_tsmhandler(uint32_t value) { _impl_.tsmhandler_ = value; } inline void TableSampleClause::set_tsmhandler(uint32_t value) { _internal_set_tsmhandler(value); // @@protoc_insertion_point(field_set:pg_query.TableSampleClause.tsmhandler) } // repeated .pg_query.Node args = 2 [json_name = "args"]; inline int TableSampleClause::_internal_args_size() const { return _impl_.args_.size(); } inline int TableSampleClause::args_size() const { return _internal_args_size(); } inline void TableSampleClause::clear_args() { _impl_.args_.Clear(); } inline ::pg_query::Node* TableSampleClause::mutable_args(int index) { // @@protoc_insertion_point(field_mutable:pg_query.TableSampleClause.args) return _impl_.args_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* TableSampleClause::mutable_args() { // @@protoc_insertion_point(field_mutable_list:pg_query.TableSampleClause.args) return &_impl_.args_; } inline const ::pg_query::Node& TableSampleClause::_internal_args(int index) const { return _impl_.args_.Get(index); } inline const ::pg_query::Node& TableSampleClause::args(int index) const { // @@protoc_insertion_point(field_get:pg_query.TableSampleClause.args) return _internal_args(index); } inline ::pg_query::Node* TableSampleClause::_internal_add_args() { return _impl_.args_.Add(); } inline ::pg_query::Node* TableSampleClause::add_args() { ::pg_query::Node* _add = _internal_add_args(); // @@protoc_insertion_point(field_add:pg_query.TableSampleClause.args) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& TableSampleClause::args() const { // @@protoc_insertion_point(field_list:pg_query.TableSampleClause.args) return _impl_.args_; } // .pg_query.Node repeatable = 3 [json_name = "repeatable"]; inline bool TableSampleClause::_internal_has_repeatable() const { return this != internal_default_instance() && _impl_.repeatable_ != nullptr; } inline bool TableSampleClause::has_repeatable() const { return _internal_has_repeatable(); } inline void TableSampleClause::clear_repeatable() { if (GetArenaForAllocation() == nullptr && _impl_.repeatable_ != nullptr) { delete _impl_.repeatable_; } _impl_.repeatable_ = nullptr; } inline const ::pg_query::Node& TableSampleClause::_internal_repeatable() const { const ::pg_query::Node* p = _impl_.repeatable_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& TableSampleClause::repeatable() const { // @@protoc_insertion_point(field_get:pg_query.TableSampleClause.repeatable) return _internal_repeatable(); } inline void TableSampleClause::unsafe_arena_set_allocated_repeatable( ::pg_query::Node* repeatable) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.repeatable_); } _impl_.repeatable_ = repeatable; if (repeatable) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.TableSampleClause.repeatable) } inline ::pg_query::Node* TableSampleClause::release_repeatable() { ::pg_query::Node* temp = _impl_.repeatable_; _impl_.repeatable_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* TableSampleClause::unsafe_arena_release_repeatable() { // @@protoc_insertion_point(field_release:pg_query.TableSampleClause.repeatable) ::pg_query::Node* temp = _impl_.repeatable_; _impl_.repeatable_ = nullptr; return temp; } inline ::pg_query::Node* TableSampleClause::_internal_mutable_repeatable() { if (_impl_.repeatable_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.repeatable_ = p; } return _impl_.repeatable_; } inline ::pg_query::Node* TableSampleClause::mutable_repeatable() { ::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* repeatable) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.repeatable_; } if (repeatable) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(repeatable); if (message_arena != submessage_arena) { repeatable = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, repeatable, submessage_arena); } } else { } _impl_.repeatable_ = repeatable; // @@protoc_insertion_point(field_set_allocated:pg_query.TableSampleClause.repeatable) } // ------------------------------------------------------------------- // WithCheckOption // .pg_query.WCOKind kind = 1 [json_name = "kind"]; inline void WithCheckOption::clear_kind() { _impl_.kind_ = 0; } inline ::pg_query::WCOKind WithCheckOption::_internal_kind() const { return static_cast< ::pg_query::WCOKind >(_impl_.kind_); } inline ::pg_query::WCOKind WithCheckOption::kind() const { // @@protoc_insertion_point(field_get:pg_query.WithCheckOption.kind) return _internal_kind(); } inline void WithCheckOption::_internal_set_kind(::pg_query::WCOKind value) { _impl_.kind_ = value; } inline void WithCheckOption::set_kind(::pg_query::WCOKind value) { _internal_set_kind(value); // @@protoc_insertion_point(field_set:pg_query.WithCheckOption.kind) } // string relname = 2 [json_name = "relname"]; inline void WithCheckOption::clear_relname() { _impl_.relname_.ClearToEmpty(); } inline const std::string& WithCheckOption::relname() const { // @@protoc_insertion_point(field_get:pg_query.WithCheckOption.relname) return _internal_relname(); } template inline PROTOBUF_ALWAYS_INLINE void WithCheckOption::set_relname(ArgT0&& arg0, ArgT... args) { _impl_.relname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.WithCheckOption.relname) } inline std::string* WithCheckOption::mutable_relname() { 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 { return _impl_.relname_.Get(); } inline void WithCheckOption::_internal_set_relname(const std::string& value) { _impl_.relname_.Set(value, GetArenaForAllocation()); } inline std::string* WithCheckOption::_internal_mutable_relname() { return _impl_.relname_.Mutable(GetArenaForAllocation()); } inline std::string* WithCheckOption::release_relname() { // @@protoc_insertion_point(field_release:pg_query.WithCheckOption.relname) return _impl_.relname_.Release(); } inline void WithCheckOption::set_allocated_relname(std::string* relname) { if (relname != nullptr) { } else { } _impl_.relname_.SetAllocated(relname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.relname_.IsDefault()) { _impl_.relname_.Set("", GetArenaForAllocation()); } #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() { _impl_.polname_.ClearToEmpty(); } inline const std::string& WithCheckOption::polname() const { // @@protoc_insertion_point(field_get:pg_query.WithCheckOption.polname) return _internal_polname(); } template inline PROTOBUF_ALWAYS_INLINE void WithCheckOption::set_polname(ArgT0&& arg0, ArgT... args) { _impl_.polname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.WithCheckOption.polname) } inline std::string* WithCheckOption::mutable_polname() { 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 { return _impl_.polname_.Get(); } inline void WithCheckOption::_internal_set_polname(const std::string& value) { _impl_.polname_.Set(value, GetArenaForAllocation()); } inline std::string* WithCheckOption::_internal_mutable_polname() { return _impl_.polname_.Mutable(GetArenaForAllocation()); } inline std::string* WithCheckOption::release_polname() { // @@protoc_insertion_point(field_release:pg_query.WithCheckOption.polname) return _impl_.polname_.Release(); } inline void WithCheckOption::set_allocated_polname(std::string* polname) { if (polname != nullptr) { } else { } _impl_.polname_.SetAllocated(polname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.polname_.IsDefault()) { _impl_.polname_.Set("", GetArenaForAllocation()); } #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::_internal_has_qual() const { return this != internal_default_instance() && _impl_.qual_ != nullptr; } inline bool WithCheckOption::has_qual() const { return _internal_has_qual(); } inline void WithCheckOption::clear_qual() { if (GetArenaForAllocation() == nullptr && _impl_.qual_ != nullptr) { delete _impl_.qual_; } _impl_.qual_ = nullptr; } inline const ::pg_query::Node& WithCheckOption::_internal_qual() const { const ::pg_query::Node* p = _impl_.qual_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& WithCheckOption::qual() const { // @@protoc_insertion_point(field_get:pg_query.WithCheckOption.qual) return _internal_qual(); } inline void WithCheckOption::unsafe_arena_set_allocated_qual( ::pg_query::Node* qual) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.qual_); } _impl_.qual_ = qual; if (qual) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.WithCheckOption.qual) } inline ::pg_query::Node* WithCheckOption::release_qual() { ::pg_query::Node* temp = _impl_.qual_; _impl_.qual_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* WithCheckOption::unsafe_arena_release_qual() { // @@protoc_insertion_point(field_release:pg_query.WithCheckOption.qual) ::pg_query::Node* temp = _impl_.qual_; _impl_.qual_ = nullptr; return temp; } inline ::pg_query::Node* WithCheckOption::_internal_mutable_qual() { if (_impl_.qual_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.qual_ = p; } return _impl_.qual_; } inline ::pg_query::Node* WithCheckOption::mutable_qual() { ::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* qual) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.qual_; } if (qual) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(qual); if (message_arena != submessage_arena) { qual = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, qual, submessage_arena); } } else { } _impl_.qual_ = qual; // @@protoc_insertion_point(field_set_allocated:pg_query.WithCheckOption.qual) } // bool cascaded = 5 [json_name = "cascaded"]; inline void WithCheckOption::clear_cascaded() { _impl_.cascaded_ = false; } inline bool WithCheckOption::_internal_cascaded() const { return _impl_.cascaded_; } inline bool WithCheckOption::cascaded() const { // @@protoc_insertion_point(field_get:pg_query.WithCheckOption.cascaded) return _internal_cascaded(); } inline void WithCheckOption::_internal_set_cascaded(bool value) { _impl_.cascaded_ = value; } inline void WithCheckOption::set_cascaded(bool value) { _internal_set_cascaded(value); // @@protoc_insertion_point(field_set:pg_query.WithCheckOption.cascaded) } // ------------------------------------------------------------------- // SortGroupClause // uint32 tle_sort_group_ref = 1 [json_name = "tleSortGroupRef"]; inline void SortGroupClause::clear_tle_sort_group_ref() { _impl_.tle_sort_group_ref_ = 0u; } inline uint32_t SortGroupClause::_internal_tle_sort_group_ref() const { return _impl_.tle_sort_group_ref_; } 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::_internal_set_tle_sort_group_ref(uint32_t value) { _impl_.tle_sort_group_ref_ = value; } 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) } // uint32 eqop = 2 [json_name = "eqop"]; inline void SortGroupClause::clear_eqop() { _impl_.eqop_ = 0u; } inline uint32_t SortGroupClause::_internal_eqop() const { return _impl_.eqop_; } inline uint32_t SortGroupClause::eqop() const { // @@protoc_insertion_point(field_get:pg_query.SortGroupClause.eqop) return _internal_eqop(); } inline void SortGroupClause::_internal_set_eqop(uint32_t value) { _impl_.eqop_ = value; } inline void SortGroupClause::set_eqop(uint32_t value) { _internal_set_eqop(value); // @@protoc_insertion_point(field_set:pg_query.SortGroupClause.eqop) } // uint32 sortop = 3 [json_name = "sortop"]; inline void SortGroupClause::clear_sortop() { _impl_.sortop_ = 0u; } inline uint32_t SortGroupClause::_internal_sortop() const { return _impl_.sortop_; } inline uint32_t SortGroupClause::sortop() const { // @@protoc_insertion_point(field_get:pg_query.SortGroupClause.sortop) return _internal_sortop(); } inline void SortGroupClause::_internal_set_sortop(uint32_t value) { _impl_.sortop_ = value; } inline void SortGroupClause::set_sortop(uint32_t value) { _internal_set_sortop(value); // @@protoc_insertion_point(field_set:pg_query.SortGroupClause.sortop) } // bool nulls_first = 4 [json_name = "nulls_first"]; inline void SortGroupClause::clear_nulls_first() { _impl_.nulls_first_ = false; } inline bool SortGroupClause::_internal_nulls_first() const { return _impl_.nulls_first_; } inline bool SortGroupClause::nulls_first() const { // @@protoc_insertion_point(field_get:pg_query.SortGroupClause.nulls_first) return _internal_nulls_first(); } inline void SortGroupClause::_internal_set_nulls_first(bool value) { _impl_.nulls_first_ = value; } inline void SortGroupClause::set_nulls_first(bool value) { _internal_set_nulls_first(value); // @@protoc_insertion_point(field_set:pg_query.SortGroupClause.nulls_first) } // bool hashable = 5 [json_name = "hashable"]; inline void SortGroupClause::clear_hashable() { _impl_.hashable_ = false; } inline bool SortGroupClause::_internal_hashable() const { return _impl_.hashable_; } inline bool SortGroupClause::hashable() const { // @@protoc_insertion_point(field_get:pg_query.SortGroupClause.hashable) return _internal_hashable(); } inline void SortGroupClause::_internal_set_hashable(bool value) { _impl_.hashable_ = value; } inline void SortGroupClause::set_hashable(bool value) { _internal_set_hashable(value); // @@protoc_insertion_point(field_set:pg_query.SortGroupClause.hashable) } // ------------------------------------------------------------------- // GroupingSet // .pg_query.GroupingSetKind kind = 1 [json_name = "kind"]; inline void GroupingSet::clear_kind() { _impl_.kind_ = 0; } inline ::pg_query::GroupingSetKind GroupingSet::_internal_kind() const { return static_cast< ::pg_query::GroupingSetKind >(_impl_.kind_); } inline ::pg_query::GroupingSetKind GroupingSet::kind() const { // @@protoc_insertion_point(field_get:pg_query.GroupingSet.kind) return _internal_kind(); } inline void GroupingSet::_internal_set_kind(::pg_query::GroupingSetKind value) { _impl_.kind_ = value; } inline void GroupingSet::set_kind(::pg_query::GroupingSetKind value) { _internal_set_kind(value); // @@protoc_insertion_point(field_set:pg_query.GroupingSet.kind) } // repeated .pg_query.Node content = 2 [json_name = "content"]; inline int GroupingSet::_internal_content_size() const { return _impl_.content_.size(); } inline int GroupingSet::content_size() const { return _internal_content_size(); } inline void GroupingSet::clear_content() { _impl_.content_.Clear(); } inline ::pg_query::Node* GroupingSet::mutable_content(int index) { // @@protoc_insertion_point(field_mutable:pg_query.GroupingSet.content) return _impl_.content_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* GroupingSet::mutable_content() { // @@protoc_insertion_point(field_mutable_list:pg_query.GroupingSet.content) return &_impl_.content_; } inline const ::pg_query::Node& GroupingSet::_internal_content(int index) const { return _impl_.content_.Get(index); } inline const ::pg_query::Node& GroupingSet::content(int index) const { // @@protoc_insertion_point(field_get:pg_query.GroupingSet.content) return _internal_content(index); } inline ::pg_query::Node* GroupingSet::_internal_add_content() { return _impl_.content_.Add(); } inline ::pg_query::Node* GroupingSet::add_content() { ::pg_query::Node* _add = _internal_add_content(); // @@protoc_insertion_point(field_add:pg_query.GroupingSet.content) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& GroupingSet::content() const { // @@protoc_insertion_point(field_list:pg_query.GroupingSet.content) return _impl_.content_; } // int32 location = 3 [json_name = "location"]; inline void GroupingSet::clear_location() { _impl_.location_ = 0; } inline int32_t GroupingSet::_internal_location() const { return _impl_.location_; } inline int32_t GroupingSet::location() const { // @@protoc_insertion_point(field_get:pg_query.GroupingSet.location) return _internal_location(); } inline void GroupingSet::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void GroupingSet::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.GroupingSet.location) } // ------------------------------------------------------------------- // WindowClause // string name = 1 [json_name = "name"]; inline void WindowClause::clear_name() { _impl_.name_.ClearToEmpty(); } inline const std::string& WindowClause::name() const { // @@protoc_insertion_point(field_get:pg_query.WindowClause.name) return _internal_name(); } template inline PROTOBUF_ALWAYS_INLINE void WindowClause::set_name(ArgT0&& arg0, ArgT... args) { _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.WindowClause.name) } inline std::string* WindowClause::mutable_name() { 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 { return _impl_.name_.Get(); } inline void WindowClause::_internal_set_name(const std::string& value) { _impl_.name_.Set(value, GetArenaForAllocation()); } inline std::string* WindowClause::_internal_mutable_name() { return _impl_.name_.Mutable(GetArenaForAllocation()); } inline std::string* WindowClause::release_name() { // @@protoc_insertion_point(field_release:pg_query.WindowClause.name) return _impl_.name_.Release(); } inline void WindowClause::set_allocated_name(std::string* name) { if (name != nullptr) { } else { } _impl_.name_.SetAllocated(name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.name_.IsDefault()) { _impl_.name_.Set("", GetArenaForAllocation()); } #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() { _impl_.refname_.ClearToEmpty(); } inline const std::string& WindowClause::refname() const { // @@protoc_insertion_point(field_get:pg_query.WindowClause.refname) return _internal_refname(); } template inline PROTOBUF_ALWAYS_INLINE void WindowClause::set_refname(ArgT0&& arg0, ArgT... args) { _impl_.refname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.WindowClause.refname) } inline std::string* WindowClause::mutable_refname() { 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 { return _impl_.refname_.Get(); } inline void WindowClause::_internal_set_refname(const std::string& value) { _impl_.refname_.Set(value, GetArenaForAllocation()); } inline std::string* WindowClause::_internal_mutable_refname() { return _impl_.refname_.Mutable(GetArenaForAllocation()); } inline std::string* WindowClause::release_refname() { // @@protoc_insertion_point(field_release:pg_query.WindowClause.refname) return _impl_.refname_.Release(); } inline void WindowClause::set_allocated_refname(std::string* refname) { if (refname != nullptr) { } else { } _impl_.refname_.SetAllocated(refname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.refname_.IsDefault()) { _impl_.refname_.Set("", GetArenaForAllocation()); } #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 _impl_.partition_clause_.size(); } inline int WindowClause::partition_clause_size() const { return _internal_partition_clause_size(); } inline void WindowClause::clear_partition_clause() { _impl_.partition_clause_.Clear(); } inline ::pg_query::Node* WindowClause::mutable_partition_clause(int index) { // @@protoc_insertion_point(field_mutable:pg_query.WindowClause.partition_clause) return _impl_.partition_clause_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* WindowClause::mutable_partition_clause() { // @@protoc_insertion_point(field_mutable_list:pg_query.WindowClause.partition_clause) return &_impl_.partition_clause_; } inline const ::pg_query::Node& WindowClause::_internal_partition_clause(int index) const { return _impl_.partition_clause_.Get(index); } inline const ::pg_query::Node& WindowClause::partition_clause(int index) const { // @@protoc_insertion_point(field_get:pg_query.WindowClause.partition_clause) return _internal_partition_clause(index); } inline ::pg_query::Node* WindowClause::_internal_add_partition_clause() { return _impl_.partition_clause_.Add(); } inline ::pg_query::Node* WindowClause::add_partition_clause() { ::pg_query::Node* _add = _internal_add_partition_clause(); // @@protoc_insertion_point(field_add:pg_query.WindowClause.partition_clause) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& WindowClause::partition_clause() const { // @@protoc_insertion_point(field_list:pg_query.WindowClause.partition_clause) return _impl_.partition_clause_; } // repeated .pg_query.Node order_clause = 4 [json_name = "orderClause"]; inline int WindowClause::_internal_order_clause_size() const { return _impl_.order_clause_.size(); } inline int WindowClause::order_clause_size() const { return _internal_order_clause_size(); } inline void WindowClause::clear_order_clause() { _impl_.order_clause_.Clear(); } inline ::pg_query::Node* WindowClause::mutable_order_clause(int index) { // @@protoc_insertion_point(field_mutable:pg_query.WindowClause.order_clause) return _impl_.order_clause_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* WindowClause::mutable_order_clause() { // @@protoc_insertion_point(field_mutable_list:pg_query.WindowClause.order_clause) return &_impl_.order_clause_; } inline const ::pg_query::Node& WindowClause::_internal_order_clause(int index) const { return _impl_.order_clause_.Get(index); } inline const ::pg_query::Node& WindowClause::order_clause(int index) const { // @@protoc_insertion_point(field_get:pg_query.WindowClause.order_clause) return _internal_order_clause(index); } inline ::pg_query::Node* WindowClause::_internal_add_order_clause() { return _impl_.order_clause_.Add(); } inline ::pg_query::Node* WindowClause::add_order_clause() { ::pg_query::Node* _add = _internal_add_order_clause(); // @@protoc_insertion_point(field_add:pg_query.WindowClause.order_clause) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& WindowClause::order_clause() const { // @@protoc_insertion_point(field_list:pg_query.WindowClause.order_clause) return _impl_.order_clause_; } // int32 frame_options = 5 [json_name = "frameOptions"]; inline void WindowClause::clear_frame_options() { _impl_.frame_options_ = 0; } inline int32_t WindowClause::_internal_frame_options() const { return _impl_.frame_options_; } inline int32_t WindowClause::frame_options() const { // @@protoc_insertion_point(field_get:pg_query.WindowClause.frame_options) return _internal_frame_options(); } inline void WindowClause::_internal_set_frame_options(int32_t value) { _impl_.frame_options_ = value; } inline void WindowClause::set_frame_options(int32_t value) { _internal_set_frame_options(value); // @@protoc_insertion_point(field_set:pg_query.WindowClause.frame_options) } // .pg_query.Node start_offset = 6 [json_name = "startOffset"]; inline bool WindowClause::_internal_has_start_offset() const { return this != internal_default_instance() && _impl_.start_offset_ != nullptr; } inline bool WindowClause::has_start_offset() const { return _internal_has_start_offset(); } inline void WindowClause::clear_start_offset() { if (GetArenaForAllocation() == nullptr && _impl_.start_offset_ != nullptr) { delete _impl_.start_offset_; } _impl_.start_offset_ = nullptr; } inline const ::pg_query::Node& WindowClause::_internal_start_offset() const { const ::pg_query::Node* p = _impl_.start_offset_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& WindowClause::start_offset() const { // @@protoc_insertion_point(field_get:pg_query.WindowClause.start_offset) return _internal_start_offset(); } inline void WindowClause::unsafe_arena_set_allocated_start_offset( ::pg_query::Node* start_offset) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.start_offset_); } _impl_.start_offset_ = start_offset; if (start_offset) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.WindowClause.start_offset) } inline ::pg_query::Node* WindowClause::release_start_offset() { ::pg_query::Node* temp = _impl_.start_offset_; _impl_.start_offset_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* WindowClause::unsafe_arena_release_start_offset() { // @@protoc_insertion_point(field_release:pg_query.WindowClause.start_offset) ::pg_query::Node* temp = _impl_.start_offset_; _impl_.start_offset_ = nullptr; return temp; } inline ::pg_query::Node* WindowClause::_internal_mutable_start_offset() { if (_impl_.start_offset_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.start_offset_ = p; } return _impl_.start_offset_; } inline ::pg_query::Node* WindowClause::mutable_start_offset() { ::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* start_offset) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.start_offset_; } if (start_offset) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(start_offset); if (message_arena != submessage_arena) { start_offset = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, start_offset, submessage_arena); } } else { } _impl_.start_offset_ = start_offset; // @@protoc_insertion_point(field_set_allocated:pg_query.WindowClause.start_offset) } // .pg_query.Node end_offset = 7 [json_name = "endOffset"]; inline bool WindowClause::_internal_has_end_offset() const { return this != internal_default_instance() && _impl_.end_offset_ != nullptr; } inline bool WindowClause::has_end_offset() const { return _internal_has_end_offset(); } inline void WindowClause::clear_end_offset() { if (GetArenaForAllocation() == nullptr && _impl_.end_offset_ != nullptr) { delete _impl_.end_offset_; } _impl_.end_offset_ = nullptr; } inline const ::pg_query::Node& WindowClause::_internal_end_offset() const { const ::pg_query::Node* p = _impl_.end_offset_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& WindowClause::end_offset() const { // @@protoc_insertion_point(field_get:pg_query.WindowClause.end_offset) return _internal_end_offset(); } inline void WindowClause::unsafe_arena_set_allocated_end_offset( ::pg_query::Node* end_offset) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.end_offset_); } _impl_.end_offset_ = end_offset; if (end_offset) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.WindowClause.end_offset) } inline ::pg_query::Node* WindowClause::release_end_offset() { ::pg_query::Node* temp = _impl_.end_offset_; _impl_.end_offset_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* WindowClause::unsafe_arena_release_end_offset() { // @@protoc_insertion_point(field_release:pg_query.WindowClause.end_offset) ::pg_query::Node* temp = _impl_.end_offset_; _impl_.end_offset_ = nullptr; return temp; } inline ::pg_query::Node* WindowClause::_internal_mutable_end_offset() { if (_impl_.end_offset_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.end_offset_ = p; } return _impl_.end_offset_; } inline ::pg_query::Node* WindowClause::mutable_end_offset() { ::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* end_offset) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.end_offset_; } if (end_offset) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(end_offset); if (message_arena != submessage_arena) { end_offset = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, end_offset, submessage_arena); } } else { } _impl_.end_offset_ = end_offset; // @@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 _impl_.run_condition_.size(); } inline int WindowClause::run_condition_size() const { return _internal_run_condition_size(); } inline void WindowClause::clear_run_condition() { _impl_.run_condition_.Clear(); } inline ::pg_query::Node* WindowClause::mutable_run_condition(int index) { // @@protoc_insertion_point(field_mutable:pg_query.WindowClause.run_condition) return _impl_.run_condition_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* WindowClause::mutable_run_condition() { // @@protoc_insertion_point(field_mutable_list:pg_query.WindowClause.run_condition) return &_impl_.run_condition_; } inline const ::pg_query::Node& WindowClause::_internal_run_condition(int index) const { return _impl_.run_condition_.Get(index); } inline const ::pg_query::Node& WindowClause::run_condition(int index) const { // @@protoc_insertion_point(field_get:pg_query.WindowClause.run_condition) return _internal_run_condition(index); } inline ::pg_query::Node* WindowClause::_internal_add_run_condition() { return _impl_.run_condition_.Add(); } inline ::pg_query::Node* WindowClause::add_run_condition() { ::pg_query::Node* _add = _internal_add_run_condition(); // @@protoc_insertion_point(field_add:pg_query.WindowClause.run_condition) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& WindowClause::run_condition() const { // @@protoc_insertion_point(field_list:pg_query.WindowClause.run_condition) return _impl_.run_condition_; } // uint32 start_in_range_func = 9 [json_name = "startInRangeFunc"]; inline void WindowClause::clear_start_in_range_func() { _impl_.start_in_range_func_ = 0u; } inline uint32_t WindowClause::_internal_start_in_range_func() const { return _impl_.start_in_range_func_; } 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::_internal_set_start_in_range_func(uint32_t value) { _impl_.start_in_range_func_ = value; } 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) } // uint32 end_in_range_func = 10 [json_name = "endInRangeFunc"]; inline void WindowClause::clear_end_in_range_func() { _impl_.end_in_range_func_ = 0u; } inline uint32_t WindowClause::_internal_end_in_range_func() const { return _impl_.end_in_range_func_; } 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::_internal_set_end_in_range_func(uint32_t value) { _impl_.end_in_range_func_ = value; } 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) } // uint32 in_range_coll = 11 [json_name = "inRangeColl"]; inline void WindowClause::clear_in_range_coll() { _impl_.in_range_coll_ = 0u; } inline uint32_t WindowClause::_internal_in_range_coll() const { return _impl_.in_range_coll_; } 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::_internal_set_in_range_coll(uint32_t value) { _impl_.in_range_coll_ = value; } 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) } // bool in_range_asc = 12 [json_name = "inRangeAsc"]; inline void WindowClause::clear_in_range_asc() { _impl_.in_range_asc_ = false; } inline bool WindowClause::_internal_in_range_asc() const { return _impl_.in_range_asc_; } inline bool WindowClause::in_range_asc() const { // @@protoc_insertion_point(field_get:pg_query.WindowClause.in_range_asc) return _internal_in_range_asc(); } inline void WindowClause::_internal_set_in_range_asc(bool value) { _impl_.in_range_asc_ = value; } inline void WindowClause::set_in_range_asc(bool value) { _internal_set_in_range_asc(value); // @@protoc_insertion_point(field_set:pg_query.WindowClause.in_range_asc) } // bool in_range_nulls_first = 13 [json_name = "inRangeNullsFirst"]; inline void WindowClause::clear_in_range_nulls_first() { _impl_.in_range_nulls_first_ = false; } inline bool WindowClause::_internal_in_range_nulls_first() const { return _impl_.in_range_nulls_first_; } inline bool WindowClause::in_range_nulls_first() const { // @@protoc_insertion_point(field_get:pg_query.WindowClause.in_range_nulls_first) return _internal_in_range_nulls_first(); } inline void WindowClause::_internal_set_in_range_nulls_first(bool value) { _impl_.in_range_nulls_first_ = value; } inline void WindowClause::set_in_range_nulls_first(bool value) { _internal_set_in_range_nulls_first(value); // @@protoc_insertion_point(field_set:pg_query.WindowClause.in_range_nulls_first) } // uint32 winref = 14 [json_name = "winref"]; inline void WindowClause::clear_winref() { _impl_.winref_ = 0u; } inline uint32_t WindowClause::_internal_winref() const { return _impl_.winref_; } inline uint32_t WindowClause::winref() const { // @@protoc_insertion_point(field_get:pg_query.WindowClause.winref) return _internal_winref(); } inline void WindowClause::_internal_set_winref(uint32_t value) { _impl_.winref_ = value; } inline void WindowClause::set_winref(uint32_t value) { _internal_set_winref(value); // @@protoc_insertion_point(field_set:pg_query.WindowClause.winref) } // bool copied_order = 15 [json_name = "copiedOrder"]; inline void WindowClause::clear_copied_order() { _impl_.copied_order_ = false; } inline bool WindowClause::_internal_copied_order() const { return _impl_.copied_order_; } inline bool WindowClause::copied_order() const { // @@protoc_insertion_point(field_get:pg_query.WindowClause.copied_order) return _internal_copied_order(); } inline void WindowClause::_internal_set_copied_order(bool value) { _impl_.copied_order_ = value; } inline void WindowClause::set_copied_order(bool value) { _internal_set_copied_order(value); // @@protoc_insertion_point(field_set:pg_query.WindowClause.copied_order) } // ------------------------------------------------------------------- // ObjectWithArgs // repeated .pg_query.Node objname = 1 [json_name = "objname"]; inline int ObjectWithArgs::_internal_objname_size() const { return _impl_.objname_.size(); } inline int ObjectWithArgs::objname_size() const { return _internal_objname_size(); } inline void ObjectWithArgs::clear_objname() { _impl_.objname_.Clear(); } inline ::pg_query::Node* ObjectWithArgs::mutable_objname(int index) { // @@protoc_insertion_point(field_mutable:pg_query.ObjectWithArgs.objname) return _impl_.objname_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* ObjectWithArgs::mutable_objname() { // @@protoc_insertion_point(field_mutable_list:pg_query.ObjectWithArgs.objname) return &_impl_.objname_; } inline const ::pg_query::Node& ObjectWithArgs::_internal_objname(int index) const { return _impl_.objname_.Get(index); } inline const ::pg_query::Node& ObjectWithArgs::objname(int index) const { // @@protoc_insertion_point(field_get:pg_query.ObjectWithArgs.objname) return _internal_objname(index); } inline ::pg_query::Node* ObjectWithArgs::_internal_add_objname() { return _impl_.objname_.Add(); } inline ::pg_query::Node* ObjectWithArgs::add_objname() { ::pg_query::Node* _add = _internal_add_objname(); // @@protoc_insertion_point(field_add:pg_query.ObjectWithArgs.objname) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& ObjectWithArgs::objname() const { // @@protoc_insertion_point(field_list:pg_query.ObjectWithArgs.objname) return _impl_.objname_; } // repeated .pg_query.Node objargs = 2 [json_name = "objargs"]; inline int ObjectWithArgs::_internal_objargs_size() const { return _impl_.objargs_.size(); } inline int ObjectWithArgs::objargs_size() const { return _internal_objargs_size(); } inline void ObjectWithArgs::clear_objargs() { _impl_.objargs_.Clear(); } inline ::pg_query::Node* ObjectWithArgs::mutable_objargs(int index) { // @@protoc_insertion_point(field_mutable:pg_query.ObjectWithArgs.objargs) return _impl_.objargs_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* ObjectWithArgs::mutable_objargs() { // @@protoc_insertion_point(field_mutable_list:pg_query.ObjectWithArgs.objargs) return &_impl_.objargs_; } inline const ::pg_query::Node& ObjectWithArgs::_internal_objargs(int index) const { return _impl_.objargs_.Get(index); } inline const ::pg_query::Node& ObjectWithArgs::objargs(int index) const { // @@protoc_insertion_point(field_get:pg_query.ObjectWithArgs.objargs) return _internal_objargs(index); } inline ::pg_query::Node* ObjectWithArgs::_internal_add_objargs() { return _impl_.objargs_.Add(); } inline ::pg_query::Node* ObjectWithArgs::add_objargs() { ::pg_query::Node* _add = _internal_add_objargs(); // @@protoc_insertion_point(field_add:pg_query.ObjectWithArgs.objargs) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& ObjectWithArgs::objargs() const { // @@protoc_insertion_point(field_list:pg_query.ObjectWithArgs.objargs) return _impl_.objargs_; } // repeated .pg_query.Node objfuncargs = 3 [json_name = "objfuncargs"]; inline int ObjectWithArgs::_internal_objfuncargs_size() const { return _impl_.objfuncargs_.size(); } inline int ObjectWithArgs::objfuncargs_size() const { return _internal_objfuncargs_size(); } inline void ObjectWithArgs::clear_objfuncargs() { _impl_.objfuncargs_.Clear(); } inline ::pg_query::Node* ObjectWithArgs::mutable_objfuncargs(int index) { // @@protoc_insertion_point(field_mutable:pg_query.ObjectWithArgs.objfuncargs) return _impl_.objfuncargs_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* ObjectWithArgs::mutable_objfuncargs() { // @@protoc_insertion_point(field_mutable_list:pg_query.ObjectWithArgs.objfuncargs) return &_impl_.objfuncargs_; } inline const ::pg_query::Node& ObjectWithArgs::_internal_objfuncargs(int index) const { return _impl_.objfuncargs_.Get(index); } inline const ::pg_query::Node& ObjectWithArgs::objfuncargs(int index) const { // @@protoc_insertion_point(field_get:pg_query.ObjectWithArgs.objfuncargs) return _internal_objfuncargs(index); } inline ::pg_query::Node* ObjectWithArgs::_internal_add_objfuncargs() { return _impl_.objfuncargs_.Add(); } inline ::pg_query::Node* ObjectWithArgs::add_objfuncargs() { ::pg_query::Node* _add = _internal_add_objfuncargs(); // @@protoc_insertion_point(field_add:pg_query.ObjectWithArgs.objfuncargs) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& ObjectWithArgs::objfuncargs() const { // @@protoc_insertion_point(field_list:pg_query.ObjectWithArgs.objfuncargs) return _impl_.objfuncargs_; } // bool args_unspecified = 4 [json_name = "args_unspecified"]; inline void ObjectWithArgs::clear_args_unspecified() { _impl_.args_unspecified_ = false; } inline bool ObjectWithArgs::_internal_args_unspecified() const { return _impl_.args_unspecified_; } inline bool ObjectWithArgs::args_unspecified() const { // @@protoc_insertion_point(field_get:pg_query.ObjectWithArgs.args_unspecified) return _internal_args_unspecified(); } inline void ObjectWithArgs::_internal_set_args_unspecified(bool value) { _impl_.args_unspecified_ = value; } inline void ObjectWithArgs::set_args_unspecified(bool value) { _internal_set_args_unspecified(value); // @@protoc_insertion_point(field_set:pg_query.ObjectWithArgs.args_unspecified) } // ------------------------------------------------------------------- // AccessPriv // string priv_name = 1 [json_name = "priv_name"]; inline void AccessPriv::clear_priv_name() { _impl_.priv_name_.ClearToEmpty(); } inline const std::string& AccessPriv::priv_name() const { // @@protoc_insertion_point(field_get:pg_query.AccessPriv.priv_name) return _internal_priv_name(); } template inline PROTOBUF_ALWAYS_INLINE void AccessPriv::set_priv_name(ArgT0&& arg0, ArgT... args) { _impl_.priv_name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.AccessPriv.priv_name) } inline std::string* AccessPriv::mutable_priv_name() { 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 { return _impl_.priv_name_.Get(); } inline void AccessPriv::_internal_set_priv_name(const std::string& value) { _impl_.priv_name_.Set(value, GetArenaForAllocation()); } inline std::string* AccessPriv::_internal_mutable_priv_name() { return _impl_.priv_name_.Mutable(GetArenaForAllocation()); } inline std::string* AccessPriv::release_priv_name() { // @@protoc_insertion_point(field_release:pg_query.AccessPriv.priv_name) return _impl_.priv_name_.Release(); } inline void AccessPriv::set_allocated_priv_name(std::string* priv_name) { if (priv_name != nullptr) { } else { } _impl_.priv_name_.SetAllocated(priv_name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.priv_name_.IsDefault()) { _impl_.priv_name_.Set("", GetArenaForAllocation()); } #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 _impl_.cols_.size(); } inline int AccessPriv::cols_size() const { return _internal_cols_size(); } inline void AccessPriv::clear_cols() { _impl_.cols_.Clear(); } inline ::pg_query::Node* AccessPriv::mutable_cols(int index) { // @@protoc_insertion_point(field_mutable:pg_query.AccessPriv.cols) return _impl_.cols_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* AccessPriv::mutable_cols() { // @@protoc_insertion_point(field_mutable_list:pg_query.AccessPriv.cols) return &_impl_.cols_; } inline const ::pg_query::Node& AccessPriv::_internal_cols(int index) const { return _impl_.cols_.Get(index); } inline const ::pg_query::Node& AccessPriv::cols(int index) const { // @@protoc_insertion_point(field_get:pg_query.AccessPriv.cols) return _internal_cols(index); } inline ::pg_query::Node* AccessPriv::_internal_add_cols() { return _impl_.cols_.Add(); } inline ::pg_query::Node* AccessPriv::add_cols() { ::pg_query::Node* _add = _internal_add_cols(); // @@protoc_insertion_point(field_add:pg_query.AccessPriv.cols) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& AccessPriv::cols() const { // @@protoc_insertion_point(field_list:pg_query.AccessPriv.cols) return _impl_.cols_; } // ------------------------------------------------------------------- // CreateOpClassItem // int32 itemtype = 1 [json_name = "itemtype"]; inline void CreateOpClassItem::clear_itemtype() { _impl_.itemtype_ = 0; } inline int32_t CreateOpClassItem::_internal_itemtype() const { return _impl_.itemtype_; } inline int32_t CreateOpClassItem::itemtype() const { // @@protoc_insertion_point(field_get:pg_query.CreateOpClassItem.itemtype) return _internal_itemtype(); } inline void CreateOpClassItem::_internal_set_itemtype(int32_t value) { _impl_.itemtype_ = value; } inline void CreateOpClassItem::set_itemtype(int32_t value) { _internal_set_itemtype(value); // @@protoc_insertion_point(field_set:pg_query.CreateOpClassItem.itemtype) } // .pg_query.ObjectWithArgs name = 2 [json_name = "name"]; inline bool CreateOpClassItem::_internal_has_name() const { return this != internal_default_instance() && _impl_.name_ != nullptr; } inline bool CreateOpClassItem::has_name() const { return _internal_has_name(); } inline void CreateOpClassItem::clear_name() { if (GetArenaForAllocation() == nullptr && _impl_.name_ != nullptr) { delete _impl_.name_; } _impl_.name_ = nullptr; } inline const ::pg_query::ObjectWithArgs& CreateOpClassItem::_internal_name() const { const ::pg_query::ObjectWithArgs* p = _impl_.name_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_ObjectWithArgs_default_instance_); } inline const ::pg_query::ObjectWithArgs& CreateOpClassItem::name() const { // @@protoc_insertion_point(field_get:pg_query.CreateOpClassItem.name) return _internal_name(); } inline void CreateOpClassItem::unsafe_arena_set_allocated_name( ::pg_query::ObjectWithArgs* name) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.name_); } _impl_.name_ = name; if (name) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateOpClassItem.name) } inline ::pg_query::ObjectWithArgs* CreateOpClassItem::release_name() { ::pg_query::ObjectWithArgs* temp = _impl_.name_; _impl_.name_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::ObjectWithArgs* CreateOpClassItem::unsafe_arena_release_name() { // @@protoc_insertion_point(field_release:pg_query.CreateOpClassItem.name) ::pg_query::ObjectWithArgs* temp = _impl_.name_; _impl_.name_ = nullptr; return temp; } inline ::pg_query::ObjectWithArgs* CreateOpClassItem::_internal_mutable_name() { if (_impl_.name_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::ObjectWithArgs>(GetArenaForAllocation()); _impl_.name_ = p; } return _impl_.name_; } inline ::pg_query::ObjectWithArgs* CreateOpClassItem::mutable_name() { ::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* name) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.name_; } if (name) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(name); if (message_arena != submessage_arena) { name = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, name, submessage_arena); } } else { } _impl_.name_ = name; // @@protoc_insertion_point(field_set_allocated:pg_query.CreateOpClassItem.name) } // int32 number = 3 [json_name = "number"]; inline void CreateOpClassItem::clear_number() { _impl_.number_ = 0; } inline int32_t CreateOpClassItem::_internal_number() const { return _impl_.number_; } inline int32_t CreateOpClassItem::number() const { // @@protoc_insertion_point(field_get:pg_query.CreateOpClassItem.number) return _internal_number(); } inline void CreateOpClassItem::_internal_set_number(int32_t value) { _impl_.number_ = value; } inline void CreateOpClassItem::set_number(int32_t value) { _internal_set_number(value); // @@protoc_insertion_point(field_set:pg_query.CreateOpClassItem.number) } // repeated .pg_query.Node order_family = 4 [json_name = "order_family"]; inline int CreateOpClassItem::_internal_order_family_size() const { return _impl_.order_family_.size(); } inline int CreateOpClassItem::order_family_size() const { return _internal_order_family_size(); } inline void CreateOpClassItem::clear_order_family() { _impl_.order_family_.Clear(); } inline ::pg_query::Node* CreateOpClassItem::mutable_order_family(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateOpClassItem.order_family) return _impl_.order_family_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateOpClassItem::mutable_order_family() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateOpClassItem.order_family) return &_impl_.order_family_; } inline const ::pg_query::Node& CreateOpClassItem::_internal_order_family(int index) const { return _impl_.order_family_.Get(index); } inline const ::pg_query::Node& CreateOpClassItem::order_family(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateOpClassItem.order_family) return _internal_order_family(index); } inline ::pg_query::Node* CreateOpClassItem::_internal_add_order_family() { return _impl_.order_family_.Add(); } inline ::pg_query::Node* CreateOpClassItem::add_order_family() { ::pg_query::Node* _add = _internal_add_order_family(); // @@protoc_insertion_point(field_add:pg_query.CreateOpClassItem.order_family) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateOpClassItem::order_family() const { // @@protoc_insertion_point(field_list:pg_query.CreateOpClassItem.order_family) return _impl_.order_family_; } // repeated .pg_query.Node class_args = 5 [json_name = "class_args"]; inline int CreateOpClassItem::_internal_class_args_size() const { return _impl_.class_args_.size(); } inline int CreateOpClassItem::class_args_size() const { return _internal_class_args_size(); } inline void CreateOpClassItem::clear_class_args() { _impl_.class_args_.Clear(); } inline ::pg_query::Node* CreateOpClassItem::mutable_class_args(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CreateOpClassItem.class_args) return _impl_.class_args_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CreateOpClassItem::mutable_class_args() { // @@protoc_insertion_point(field_mutable_list:pg_query.CreateOpClassItem.class_args) return &_impl_.class_args_; } inline const ::pg_query::Node& CreateOpClassItem::_internal_class_args(int index) const { return _impl_.class_args_.Get(index); } inline const ::pg_query::Node& CreateOpClassItem::class_args(int index) const { // @@protoc_insertion_point(field_get:pg_query.CreateOpClassItem.class_args) return _internal_class_args(index); } inline ::pg_query::Node* CreateOpClassItem::_internal_add_class_args() { return _impl_.class_args_.Add(); } inline ::pg_query::Node* CreateOpClassItem::add_class_args() { ::pg_query::Node* _add = _internal_add_class_args(); // @@protoc_insertion_point(field_add:pg_query.CreateOpClassItem.class_args) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CreateOpClassItem::class_args() const { // @@protoc_insertion_point(field_list:pg_query.CreateOpClassItem.class_args) return _impl_.class_args_; } // .pg_query.TypeName storedtype = 6 [json_name = "storedtype"]; inline bool CreateOpClassItem::_internal_has_storedtype() const { return this != internal_default_instance() && _impl_.storedtype_ != nullptr; } inline bool CreateOpClassItem::has_storedtype() const { return _internal_has_storedtype(); } inline void CreateOpClassItem::clear_storedtype() { if (GetArenaForAllocation() == nullptr && _impl_.storedtype_ != nullptr) { delete _impl_.storedtype_; } _impl_.storedtype_ = nullptr; } inline const ::pg_query::TypeName& CreateOpClassItem::_internal_storedtype() const { const ::pg_query::TypeName* p = _impl_.storedtype_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_TypeName_default_instance_); } inline const ::pg_query::TypeName& CreateOpClassItem::storedtype() const { // @@protoc_insertion_point(field_get:pg_query.CreateOpClassItem.storedtype) return _internal_storedtype(); } inline void CreateOpClassItem::unsafe_arena_set_allocated_storedtype( ::pg_query::TypeName* storedtype) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.storedtype_); } _impl_.storedtype_ = storedtype; if (storedtype) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CreateOpClassItem.storedtype) } inline ::pg_query::TypeName* CreateOpClassItem::release_storedtype() { ::pg_query::TypeName* temp = _impl_.storedtype_; _impl_.storedtype_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::TypeName* CreateOpClassItem::unsafe_arena_release_storedtype() { // @@protoc_insertion_point(field_release:pg_query.CreateOpClassItem.storedtype) ::pg_query::TypeName* temp = _impl_.storedtype_; _impl_.storedtype_ = nullptr; return temp; } inline ::pg_query::TypeName* CreateOpClassItem::_internal_mutable_storedtype() { if (_impl_.storedtype_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArenaForAllocation()); _impl_.storedtype_ = p; } return _impl_.storedtype_; } inline ::pg_query::TypeName* CreateOpClassItem::mutable_storedtype() { ::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* storedtype) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.storedtype_; } if (storedtype) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(storedtype); if (message_arena != submessage_arena) { storedtype = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, storedtype, submessage_arena); } } else { } _impl_.storedtype_ = storedtype; // @@protoc_insertion_point(field_set_allocated:pg_query.CreateOpClassItem.storedtype) } // ------------------------------------------------------------------- // TableLikeClause // .pg_query.RangeVar relation = 1 [json_name = "relation"]; inline bool TableLikeClause::_internal_has_relation() const { return this != internal_default_instance() && _impl_.relation_ != nullptr; } inline bool TableLikeClause::has_relation() const { return _internal_has_relation(); } inline void TableLikeClause::clear_relation() { if (GetArenaForAllocation() == nullptr && _impl_.relation_ != nullptr) { delete _impl_.relation_; } _impl_.relation_ = nullptr; } inline const ::pg_query::RangeVar& TableLikeClause::_internal_relation() const { const ::pg_query::RangeVar* p = _impl_.relation_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& TableLikeClause::relation() const { // @@protoc_insertion_point(field_get:pg_query.TableLikeClause.relation) return _internal_relation(); } inline void TableLikeClause::unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.relation_); } _impl_.relation_ = relation; if (relation) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.TableLikeClause.relation) } inline ::pg_query::RangeVar* TableLikeClause::release_relation() { ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* TableLikeClause::unsafe_arena_release_relation() { // @@protoc_insertion_point(field_release:pg_query.TableLikeClause.relation) ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; return temp; } inline ::pg_query::RangeVar* TableLikeClause::_internal_mutable_relation() { if (_impl_.relation_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.relation_ = p; } return _impl_.relation_; } inline ::pg_query::RangeVar* TableLikeClause::mutable_relation() { ::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* relation) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.relation_; } if (relation) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(relation); if (message_arena != submessage_arena) { relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, relation, submessage_arena); } } else { } _impl_.relation_ = relation; // @@protoc_insertion_point(field_set_allocated:pg_query.TableLikeClause.relation) } // uint32 options = 2 [json_name = "options"]; inline void TableLikeClause::clear_options() { _impl_.options_ = 0u; } inline uint32_t TableLikeClause::_internal_options() const { return _impl_.options_; } inline uint32_t TableLikeClause::options() const { // @@protoc_insertion_point(field_get:pg_query.TableLikeClause.options) return _internal_options(); } inline void TableLikeClause::_internal_set_options(uint32_t value) { _impl_.options_ = value; } inline void TableLikeClause::set_options(uint32_t value) { _internal_set_options(value); // @@protoc_insertion_point(field_set:pg_query.TableLikeClause.options) } // uint32 relation_oid = 3 [json_name = "relationOid"]; inline void TableLikeClause::clear_relation_oid() { _impl_.relation_oid_ = 0u; } inline uint32_t TableLikeClause::_internal_relation_oid() const { return _impl_.relation_oid_; } inline uint32_t TableLikeClause::relation_oid() const { // @@protoc_insertion_point(field_get:pg_query.TableLikeClause.relation_oid) return _internal_relation_oid(); } inline void TableLikeClause::_internal_set_relation_oid(uint32_t value) { _impl_.relation_oid_ = value; } inline void TableLikeClause::set_relation_oid(uint32_t value) { _internal_set_relation_oid(value); // @@protoc_insertion_point(field_set:pg_query.TableLikeClause.relation_oid) } // ------------------------------------------------------------------- // FunctionParameter // string name = 1 [json_name = "name"]; inline void FunctionParameter::clear_name() { _impl_.name_.ClearToEmpty(); } inline const std::string& FunctionParameter::name() const { // @@protoc_insertion_point(field_get:pg_query.FunctionParameter.name) return _internal_name(); } template inline PROTOBUF_ALWAYS_INLINE void FunctionParameter::set_name(ArgT0&& arg0, ArgT... args) { _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.FunctionParameter.name) } inline std::string* FunctionParameter::mutable_name() { 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 { return _impl_.name_.Get(); } inline void FunctionParameter::_internal_set_name(const std::string& value) { _impl_.name_.Set(value, GetArenaForAllocation()); } inline std::string* FunctionParameter::_internal_mutable_name() { return _impl_.name_.Mutable(GetArenaForAllocation()); } inline std::string* FunctionParameter::release_name() { // @@protoc_insertion_point(field_release:pg_query.FunctionParameter.name) return _impl_.name_.Release(); } inline void FunctionParameter::set_allocated_name(std::string* name) { if (name != nullptr) { } else { } _impl_.name_.SetAllocated(name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.name_.IsDefault()) { _impl_.name_.Set("", GetArenaForAllocation()); } #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::_internal_has_arg_type() const { return this != internal_default_instance() && _impl_.arg_type_ != nullptr; } inline bool FunctionParameter::has_arg_type() const { return _internal_has_arg_type(); } inline void FunctionParameter::clear_arg_type() { if (GetArenaForAllocation() == nullptr && _impl_.arg_type_ != nullptr) { delete _impl_.arg_type_; } _impl_.arg_type_ = nullptr; } inline const ::pg_query::TypeName& FunctionParameter::_internal_arg_type() const { const ::pg_query::TypeName* p = _impl_.arg_type_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_TypeName_default_instance_); } inline const ::pg_query::TypeName& FunctionParameter::arg_type() const { // @@protoc_insertion_point(field_get:pg_query.FunctionParameter.arg_type) return _internal_arg_type(); } inline void FunctionParameter::unsafe_arena_set_allocated_arg_type( ::pg_query::TypeName* arg_type) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.arg_type_); } _impl_.arg_type_ = arg_type; if (arg_type) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FunctionParameter.arg_type) } inline ::pg_query::TypeName* FunctionParameter::release_arg_type() { ::pg_query::TypeName* temp = _impl_.arg_type_; _impl_.arg_type_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::TypeName* FunctionParameter::unsafe_arena_release_arg_type() { // @@protoc_insertion_point(field_release:pg_query.FunctionParameter.arg_type) ::pg_query::TypeName* temp = _impl_.arg_type_; _impl_.arg_type_ = nullptr; return temp; } inline ::pg_query::TypeName* FunctionParameter::_internal_mutable_arg_type() { if (_impl_.arg_type_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArenaForAllocation()); _impl_.arg_type_ = p; } return _impl_.arg_type_; } inline ::pg_query::TypeName* FunctionParameter::mutable_arg_type() { ::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* arg_type) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.arg_type_; } if (arg_type) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(arg_type); if (message_arena != submessage_arena) { arg_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, arg_type, submessage_arena); } } else { } _impl_.arg_type_ = arg_type; // @@protoc_insertion_point(field_set_allocated:pg_query.FunctionParameter.arg_type) } // .pg_query.FunctionParameterMode mode = 3 [json_name = "mode"]; inline void FunctionParameter::clear_mode() { _impl_.mode_ = 0; } inline ::pg_query::FunctionParameterMode FunctionParameter::_internal_mode() const { return static_cast< ::pg_query::FunctionParameterMode >(_impl_.mode_); } inline ::pg_query::FunctionParameterMode FunctionParameter::mode() const { // @@protoc_insertion_point(field_get:pg_query.FunctionParameter.mode) return _internal_mode(); } inline void FunctionParameter::_internal_set_mode(::pg_query::FunctionParameterMode value) { _impl_.mode_ = value; } inline void FunctionParameter::set_mode(::pg_query::FunctionParameterMode value) { _internal_set_mode(value); // @@protoc_insertion_point(field_set:pg_query.FunctionParameter.mode) } // .pg_query.Node defexpr = 4 [json_name = "defexpr"]; inline bool FunctionParameter::_internal_has_defexpr() const { return this != internal_default_instance() && _impl_.defexpr_ != nullptr; } inline bool FunctionParameter::has_defexpr() const { return _internal_has_defexpr(); } inline void FunctionParameter::clear_defexpr() { if (GetArenaForAllocation() == nullptr && _impl_.defexpr_ != nullptr) { delete _impl_.defexpr_; } _impl_.defexpr_ = nullptr; } inline const ::pg_query::Node& FunctionParameter::_internal_defexpr() const { const ::pg_query::Node* p = _impl_.defexpr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& FunctionParameter::defexpr() const { // @@protoc_insertion_point(field_get:pg_query.FunctionParameter.defexpr) return _internal_defexpr(); } inline void FunctionParameter::unsafe_arena_set_allocated_defexpr( ::pg_query::Node* defexpr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.defexpr_); } _impl_.defexpr_ = defexpr; if (defexpr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.FunctionParameter.defexpr) } inline ::pg_query::Node* FunctionParameter::release_defexpr() { ::pg_query::Node* temp = _impl_.defexpr_; _impl_.defexpr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* FunctionParameter::unsafe_arena_release_defexpr() { // @@protoc_insertion_point(field_release:pg_query.FunctionParameter.defexpr) ::pg_query::Node* temp = _impl_.defexpr_; _impl_.defexpr_ = nullptr; return temp; } inline ::pg_query::Node* FunctionParameter::_internal_mutable_defexpr() { if (_impl_.defexpr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.defexpr_ = p; } return _impl_.defexpr_; } inline ::pg_query::Node* FunctionParameter::mutable_defexpr() { ::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* defexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.defexpr_; } if (defexpr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(defexpr); if (message_arena != submessage_arena) { defexpr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, defexpr, submessage_arena); } } else { } _impl_.defexpr_ = defexpr; // @@protoc_insertion_point(field_set_allocated:pg_query.FunctionParameter.defexpr) } // ------------------------------------------------------------------- // LockingClause // repeated .pg_query.Node locked_rels = 1 [json_name = "lockedRels"]; inline int LockingClause::_internal_locked_rels_size() const { return _impl_.locked_rels_.size(); } inline int LockingClause::locked_rels_size() const { return _internal_locked_rels_size(); } inline void LockingClause::clear_locked_rels() { _impl_.locked_rels_.Clear(); } inline ::pg_query::Node* LockingClause::mutable_locked_rels(int index) { // @@protoc_insertion_point(field_mutable:pg_query.LockingClause.locked_rels) return _impl_.locked_rels_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* LockingClause::mutable_locked_rels() { // @@protoc_insertion_point(field_mutable_list:pg_query.LockingClause.locked_rels) return &_impl_.locked_rels_; } inline const ::pg_query::Node& LockingClause::_internal_locked_rels(int index) const { return _impl_.locked_rels_.Get(index); } inline const ::pg_query::Node& LockingClause::locked_rels(int index) const { // @@protoc_insertion_point(field_get:pg_query.LockingClause.locked_rels) return _internal_locked_rels(index); } inline ::pg_query::Node* LockingClause::_internal_add_locked_rels() { return _impl_.locked_rels_.Add(); } inline ::pg_query::Node* LockingClause::add_locked_rels() { ::pg_query::Node* _add = _internal_add_locked_rels(); // @@protoc_insertion_point(field_add:pg_query.LockingClause.locked_rels) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& LockingClause::locked_rels() const { // @@protoc_insertion_point(field_list:pg_query.LockingClause.locked_rels) return _impl_.locked_rels_; } // .pg_query.LockClauseStrength strength = 2 [json_name = "strength"]; inline void LockingClause::clear_strength() { _impl_.strength_ = 0; } inline ::pg_query::LockClauseStrength LockingClause::_internal_strength() const { return static_cast< ::pg_query::LockClauseStrength >(_impl_.strength_); } inline ::pg_query::LockClauseStrength LockingClause::strength() const { // @@protoc_insertion_point(field_get:pg_query.LockingClause.strength) return _internal_strength(); } inline void LockingClause::_internal_set_strength(::pg_query::LockClauseStrength value) { _impl_.strength_ = value; } inline void LockingClause::set_strength(::pg_query::LockClauseStrength value) { _internal_set_strength(value); // @@protoc_insertion_point(field_set:pg_query.LockingClause.strength) } // .pg_query.LockWaitPolicy wait_policy = 3 [json_name = "waitPolicy"]; inline void LockingClause::clear_wait_policy() { _impl_.wait_policy_ = 0; } inline ::pg_query::LockWaitPolicy LockingClause::_internal_wait_policy() const { return static_cast< ::pg_query::LockWaitPolicy >(_impl_.wait_policy_); } inline ::pg_query::LockWaitPolicy LockingClause::wait_policy() const { // @@protoc_insertion_point(field_get:pg_query.LockingClause.wait_policy) return _internal_wait_policy(); } inline void LockingClause::_internal_set_wait_policy(::pg_query::LockWaitPolicy value) { _impl_.wait_policy_ = value; } inline void LockingClause::set_wait_policy(::pg_query::LockWaitPolicy value) { _internal_set_wait_policy(value); // @@protoc_insertion_point(field_set:pg_query.LockingClause.wait_policy) } // ------------------------------------------------------------------- // RowMarkClause // uint32 rti = 1 [json_name = "rti"]; inline void RowMarkClause::clear_rti() { _impl_.rti_ = 0u; } inline uint32_t RowMarkClause::_internal_rti() const { return _impl_.rti_; } inline uint32_t RowMarkClause::rti() const { // @@protoc_insertion_point(field_get:pg_query.RowMarkClause.rti) return _internal_rti(); } inline void RowMarkClause::_internal_set_rti(uint32_t value) { _impl_.rti_ = value; } inline void RowMarkClause::set_rti(uint32_t value) { _internal_set_rti(value); // @@protoc_insertion_point(field_set:pg_query.RowMarkClause.rti) } // .pg_query.LockClauseStrength strength = 2 [json_name = "strength"]; inline void RowMarkClause::clear_strength() { _impl_.strength_ = 0; } inline ::pg_query::LockClauseStrength RowMarkClause::_internal_strength() const { return static_cast< ::pg_query::LockClauseStrength >(_impl_.strength_); } inline ::pg_query::LockClauseStrength RowMarkClause::strength() const { // @@protoc_insertion_point(field_get:pg_query.RowMarkClause.strength) return _internal_strength(); } inline void RowMarkClause::_internal_set_strength(::pg_query::LockClauseStrength value) { _impl_.strength_ = value; } inline void RowMarkClause::set_strength(::pg_query::LockClauseStrength value) { _internal_set_strength(value); // @@protoc_insertion_point(field_set:pg_query.RowMarkClause.strength) } // .pg_query.LockWaitPolicy wait_policy = 3 [json_name = "waitPolicy"]; inline void RowMarkClause::clear_wait_policy() { _impl_.wait_policy_ = 0; } inline ::pg_query::LockWaitPolicy RowMarkClause::_internal_wait_policy() const { return static_cast< ::pg_query::LockWaitPolicy >(_impl_.wait_policy_); } inline ::pg_query::LockWaitPolicy RowMarkClause::wait_policy() const { // @@protoc_insertion_point(field_get:pg_query.RowMarkClause.wait_policy) return _internal_wait_policy(); } inline void RowMarkClause::_internal_set_wait_policy(::pg_query::LockWaitPolicy value) { _impl_.wait_policy_ = value; } inline void RowMarkClause::set_wait_policy(::pg_query::LockWaitPolicy value) { _internal_set_wait_policy(value); // @@protoc_insertion_point(field_set:pg_query.RowMarkClause.wait_policy) } // bool pushed_down = 4 [json_name = "pushedDown"]; inline void RowMarkClause::clear_pushed_down() { _impl_.pushed_down_ = false; } inline bool RowMarkClause::_internal_pushed_down() const { return _impl_.pushed_down_; } inline bool RowMarkClause::pushed_down() const { // @@protoc_insertion_point(field_get:pg_query.RowMarkClause.pushed_down) return _internal_pushed_down(); } inline void RowMarkClause::_internal_set_pushed_down(bool value) { _impl_.pushed_down_ = value; } inline void RowMarkClause::set_pushed_down(bool value) { _internal_set_pushed_down(value); // @@protoc_insertion_point(field_set:pg_query.RowMarkClause.pushed_down) } // ------------------------------------------------------------------- // XmlSerialize // .pg_query.XmlOptionType xmloption = 1 [json_name = "xmloption"]; inline void XmlSerialize::clear_xmloption() { _impl_.xmloption_ = 0; } inline ::pg_query::XmlOptionType XmlSerialize::_internal_xmloption() const { return static_cast< ::pg_query::XmlOptionType >(_impl_.xmloption_); } inline ::pg_query::XmlOptionType XmlSerialize::xmloption() const { // @@protoc_insertion_point(field_get:pg_query.XmlSerialize.xmloption) return _internal_xmloption(); } inline void XmlSerialize::_internal_set_xmloption(::pg_query::XmlOptionType value) { _impl_.xmloption_ = value; } inline void XmlSerialize::set_xmloption(::pg_query::XmlOptionType value) { _internal_set_xmloption(value); // @@protoc_insertion_point(field_set:pg_query.XmlSerialize.xmloption) } // .pg_query.Node expr = 2 [json_name = "expr"]; inline bool XmlSerialize::_internal_has_expr() const { return this != internal_default_instance() && _impl_.expr_ != nullptr; } inline bool XmlSerialize::has_expr() const { return _internal_has_expr(); } inline void XmlSerialize::clear_expr() { if (GetArenaForAllocation() == nullptr && _impl_.expr_ != nullptr) { delete _impl_.expr_; } _impl_.expr_ = nullptr; } inline const ::pg_query::Node& XmlSerialize::_internal_expr() const { const ::pg_query::Node* p = _impl_.expr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& XmlSerialize::expr() const { // @@protoc_insertion_point(field_get:pg_query.XmlSerialize.expr) return _internal_expr(); } inline void XmlSerialize::unsafe_arena_set_allocated_expr( ::pg_query::Node* expr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.expr_); } _impl_.expr_ = expr; if (expr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.XmlSerialize.expr) } inline ::pg_query::Node* XmlSerialize::release_expr() { ::pg_query::Node* temp = _impl_.expr_; _impl_.expr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* XmlSerialize::unsafe_arena_release_expr() { // @@protoc_insertion_point(field_release:pg_query.XmlSerialize.expr) ::pg_query::Node* temp = _impl_.expr_; _impl_.expr_ = nullptr; return temp; } inline ::pg_query::Node* XmlSerialize::_internal_mutable_expr() { if (_impl_.expr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.expr_ = p; } return _impl_.expr_; } inline ::pg_query::Node* XmlSerialize::mutable_expr() { ::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* expr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.expr_; } if (expr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(expr); if (message_arena != submessage_arena) { expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, expr, submessage_arena); } } else { } _impl_.expr_ = expr; // @@protoc_insertion_point(field_set_allocated:pg_query.XmlSerialize.expr) } // .pg_query.TypeName type_name = 3 [json_name = "typeName"]; inline bool XmlSerialize::_internal_has_type_name() const { return this != internal_default_instance() && _impl_.type_name_ != nullptr; } inline bool XmlSerialize::has_type_name() const { return _internal_has_type_name(); } inline void XmlSerialize::clear_type_name() { if (GetArenaForAllocation() == nullptr && _impl_.type_name_ != nullptr) { delete _impl_.type_name_; } _impl_.type_name_ = nullptr; } inline const ::pg_query::TypeName& XmlSerialize::_internal_type_name() const { const ::pg_query::TypeName* p = _impl_.type_name_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_TypeName_default_instance_); } inline const ::pg_query::TypeName& XmlSerialize::type_name() const { // @@protoc_insertion_point(field_get:pg_query.XmlSerialize.type_name) return _internal_type_name(); } inline void XmlSerialize::unsafe_arena_set_allocated_type_name( ::pg_query::TypeName* type_name) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.type_name_); } _impl_.type_name_ = type_name; if (type_name) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.XmlSerialize.type_name) } inline ::pg_query::TypeName* XmlSerialize::release_type_name() { ::pg_query::TypeName* temp = _impl_.type_name_; _impl_.type_name_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::TypeName* XmlSerialize::unsafe_arena_release_type_name() { // @@protoc_insertion_point(field_release:pg_query.XmlSerialize.type_name) ::pg_query::TypeName* temp = _impl_.type_name_; _impl_.type_name_ = nullptr; return temp; } inline ::pg_query::TypeName* XmlSerialize::_internal_mutable_type_name() { if (_impl_.type_name_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::TypeName>(GetArenaForAllocation()); _impl_.type_name_ = p; } return _impl_.type_name_; } inline ::pg_query::TypeName* XmlSerialize::mutable_type_name() { ::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* type_name) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.type_name_; } if (type_name) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(type_name); if (message_arena != submessage_arena) { type_name = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, type_name, submessage_arena); } } else { } _impl_.type_name_ = type_name; // @@protoc_insertion_point(field_set_allocated:pg_query.XmlSerialize.type_name) } // int32 location = 4 [json_name = "location"]; inline void XmlSerialize::clear_location() { _impl_.location_ = 0; } inline int32_t XmlSerialize::_internal_location() const { return _impl_.location_; } inline int32_t XmlSerialize::location() const { // @@protoc_insertion_point(field_get:pg_query.XmlSerialize.location) return _internal_location(); } inline void XmlSerialize::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void XmlSerialize::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.XmlSerialize.location) } // ------------------------------------------------------------------- // WithClause // repeated .pg_query.Node ctes = 1 [json_name = "ctes"]; inline int WithClause::_internal_ctes_size() const { return _impl_.ctes_.size(); } inline int WithClause::ctes_size() const { return _internal_ctes_size(); } inline void WithClause::clear_ctes() { _impl_.ctes_.Clear(); } inline ::pg_query::Node* WithClause::mutable_ctes(int index) { // @@protoc_insertion_point(field_mutable:pg_query.WithClause.ctes) return _impl_.ctes_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* WithClause::mutable_ctes() { // @@protoc_insertion_point(field_mutable_list:pg_query.WithClause.ctes) return &_impl_.ctes_; } inline const ::pg_query::Node& WithClause::_internal_ctes(int index) const { return _impl_.ctes_.Get(index); } inline const ::pg_query::Node& WithClause::ctes(int index) const { // @@protoc_insertion_point(field_get:pg_query.WithClause.ctes) return _internal_ctes(index); } inline ::pg_query::Node* WithClause::_internal_add_ctes() { return _impl_.ctes_.Add(); } inline ::pg_query::Node* WithClause::add_ctes() { ::pg_query::Node* _add = _internal_add_ctes(); // @@protoc_insertion_point(field_add:pg_query.WithClause.ctes) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& WithClause::ctes() const { // @@protoc_insertion_point(field_list:pg_query.WithClause.ctes) return _impl_.ctes_; } // bool recursive = 2 [json_name = "recursive"]; inline void WithClause::clear_recursive() { _impl_.recursive_ = false; } inline bool WithClause::_internal_recursive() const { return _impl_.recursive_; } inline bool WithClause::recursive() const { // @@protoc_insertion_point(field_get:pg_query.WithClause.recursive) return _internal_recursive(); } inline void WithClause::_internal_set_recursive(bool value) { _impl_.recursive_ = value; } inline void WithClause::set_recursive(bool value) { _internal_set_recursive(value); // @@protoc_insertion_point(field_set:pg_query.WithClause.recursive) } // int32 location = 3 [json_name = "location"]; inline void WithClause::clear_location() { _impl_.location_ = 0; } inline int32_t WithClause::_internal_location() const { return _impl_.location_; } inline int32_t WithClause::location() const { // @@protoc_insertion_point(field_get:pg_query.WithClause.location) return _internal_location(); } inline void WithClause::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void WithClause::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.WithClause.location) } // ------------------------------------------------------------------- // InferClause // repeated .pg_query.Node index_elems = 1 [json_name = "indexElems"]; inline int InferClause::_internal_index_elems_size() const { return _impl_.index_elems_.size(); } inline int InferClause::index_elems_size() const { return _internal_index_elems_size(); } inline void InferClause::clear_index_elems() { _impl_.index_elems_.Clear(); } inline ::pg_query::Node* InferClause::mutable_index_elems(int index) { // @@protoc_insertion_point(field_mutable:pg_query.InferClause.index_elems) return _impl_.index_elems_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* InferClause::mutable_index_elems() { // @@protoc_insertion_point(field_mutable_list:pg_query.InferClause.index_elems) return &_impl_.index_elems_; } inline const ::pg_query::Node& InferClause::_internal_index_elems(int index) const { return _impl_.index_elems_.Get(index); } inline const ::pg_query::Node& InferClause::index_elems(int index) const { // @@protoc_insertion_point(field_get:pg_query.InferClause.index_elems) return _internal_index_elems(index); } inline ::pg_query::Node* InferClause::_internal_add_index_elems() { return _impl_.index_elems_.Add(); } inline ::pg_query::Node* InferClause::add_index_elems() { ::pg_query::Node* _add = _internal_add_index_elems(); // @@protoc_insertion_point(field_add:pg_query.InferClause.index_elems) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& InferClause::index_elems() const { // @@protoc_insertion_point(field_list:pg_query.InferClause.index_elems) return _impl_.index_elems_; } // .pg_query.Node where_clause = 2 [json_name = "whereClause"]; inline bool InferClause::_internal_has_where_clause() const { return this != internal_default_instance() && _impl_.where_clause_ != nullptr; } inline bool InferClause::has_where_clause() const { return _internal_has_where_clause(); } inline void InferClause::clear_where_clause() { if (GetArenaForAllocation() == nullptr && _impl_.where_clause_ != nullptr) { delete _impl_.where_clause_; } _impl_.where_clause_ = nullptr; } inline const ::pg_query::Node& InferClause::_internal_where_clause() const { const ::pg_query::Node* p = _impl_.where_clause_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& InferClause::where_clause() const { // @@protoc_insertion_point(field_get:pg_query.InferClause.where_clause) return _internal_where_clause(); } inline void InferClause::unsafe_arena_set_allocated_where_clause( ::pg_query::Node* where_clause) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.where_clause_); } _impl_.where_clause_ = where_clause; if (where_clause) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.InferClause.where_clause) } inline ::pg_query::Node* InferClause::release_where_clause() { ::pg_query::Node* temp = _impl_.where_clause_; _impl_.where_clause_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* InferClause::unsafe_arena_release_where_clause() { // @@protoc_insertion_point(field_release:pg_query.InferClause.where_clause) ::pg_query::Node* temp = _impl_.where_clause_; _impl_.where_clause_ = nullptr; return temp; } inline ::pg_query::Node* InferClause::_internal_mutable_where_clause() { if (_impl_.where_clause_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.where_clause_ = p; } return _impl_.where_clause_; } inline ::pg_query::Node* InferClause::mutable_where_clause() { ::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* where_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.where_clause_; } if (where_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(where_clause); if (message_arena != submessage_arena) { where_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, where_clause, submessage_arena); } } else { } _impl_.where_clause_ = where_clause; // @@protoc_insertion_point(field_set_allocated:pg_query.InferClause.where_clause) } // string conname = 3 [json_name = "conname"]; inline void InferClause::clear_conname() { _impl_.conname_.ClearToEmpty(); } inline const std::string& InferClause::conname() const { // @@protoc_insertion_point(field_get:pg_query.InferClause.conname) return _internal_conname(); } template inline PROTOBUF_ALWAYS_INLINE void InferClause::set_conname(ArgT0&& arg0, ArgT... args) { _impl_.conname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.InferClause.conname) } inline std::string* InferClause::mutable_conname() { 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 { return _impl_.conname_.Get(); } inline void InferClause::_internal_set_conname(const std::string& value) { _impl_.conname_.Set(value, GetArenaForAllocation()); } inline std::string* InferClause::_internal_mutable_conname() { return _impl_.conname_.Mutable(GetArenaForAllocation()); } inline std::string* InferClause::release_conname() { // @@protoc_insertion_point(field_release:pg_query.InferClause.conname) return _impl_.conname_.Release(); } inline void InferClause::set_allocated_conname(std::string* conname) { if (conname != nullptr) { } else { } _impl_.conname_.SetAllocated(conname, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.conname_.IsDefault()) { _impl_.conname_.Set("", GetArenaForAllocation()); } #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() { _impl_.location_ = 0; } inline int32_t InferClause::_internal_location() const { return _impl_.location_; } inline int32_t InferClause::location() const { // @@protoc_insertion_point(field_get:pg_query.InferClause.location) return _internal_location(); } inline void InferClause::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void InferClause::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.InferClause.location) } // ------------------------------------------------------------------- // OnConflictClause // .pg_query.OnConflictAction action = 1 [json_name = "action"]; inline void OnConflictClause::clear_action() { _impl_.action_ = 0; } inline ::pg_query::OnConflictAction OnConflictClause::_internal_action() const { return static_cast< ::pg_query::OnConflictAction >(_impl_.action_); } inline ::pg_query::OnConflictAction OnConflictClause::action() const { // @@protoc_insertion_point(field_get:pg_query.OnConflictClause.action) return _internal_action(); } inline void OnConflictClause::_internal_set_action(::pg_query::OnConflictAction value) { _impl_.action_ = value; } inline void OnConflictClause::set_action(::pg_query::OnConflictAction value) { _internal_set_action(value); // @@protoc_insertion_point(field_set:pg_query.OnConflictClause.action) } // .pg_query.InferClause infer = 2 [json_name = "infer"]; inline bool OnConflictClause::_internal_has_infer() const { return this != internal_default_instance() && _impl_.infer_ != nullptr; } inline bool OnConflictClause::has_infer() const { return _internal_has_infer(); } inline void OnConflictClause::clear_infer() { if (GetArenaForAllocation() == nullptr && _impl_.infer_ != nullptr) { delete _impl_.infer_; } _impl_.infer_ = nullptr; } inline const ::pg_query::InferClause& OnConflictClause::_internal_infer() const { const ::pg_query::InferClause* p = _impl_.infer_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_InferClause_default_instance_); } inline const ::pg_query::InferClause& OnConflictClause::infer() const { // @@protoc_insertion_point(field_get:pg_query.OnConflictClause.infer) return _internal_infer(); } inline void OnConflictClause::unsafe_arena_set_allocated_infer( ::pg_query::InferClause* infer) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.infer_); } _impl_.infer_ = infer; if (infer) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.OnConflictClause.infer) } inline ::pg_query::InferClause* OnConflictClause::release_infer() { ::pg_query::InferClause* temp = _impl_.infer_; _impl_.infer_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::InferClause* OnConflictClause::unsafe_arena_release_infer() { // @@protoc_insertion_point(field_release:pg_query.OnConflictClause.infer) ::pg_query::InferClause* temp = _impl_.infer_; _impl_.infer_ = nullptr; return temp; } inline ::pg_query::InferClause* OnConflictClause::_internal_mutable_infer() { if (_impl_.infer_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::InferClause>(GetArenaForAllocation()); _impl_.infer_ = p; } return _impl_.infer_; } inline ::pg_query::InferClause* OnConflictClause::mutable_infer() { ::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* infer) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.infer_; } if (infer) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(infer); if (message_arena != submessage_arena) { infer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, infer, submessage_arena); } } else { } _impl_.infer_ = infer; // @@protoc_insertion_point(field_set_allocated:pg_query.OnConflictClause.infer) } // repeated .pg_query.Node target_list = 3 [json_name = "targetList"]; inline int OnConflictClause::_internal_target_list_size() const { return _impl_.target_list_.size(); } inline int OnConflictClause::target_list_size() const { return _internal_target_list_size(); } inline void OnConflictClause::clear_target_list() { _impl_.target_list_.Clear(); } inline ::pg_query::Node* OnConflictClause::mutable_target_list(int index) { // @@protoc_insertion_point(field_mutable:pg_query.OnConflictClause.target_list) return _impl_.target_list_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* OnConflictClause::mutable_target_list() { // @@protoc_insertion_point(field_mutable_list:pg_query.OnConflictClause.target_list) return &_impl_.target_list_; } inline const ::pg_query::Node& OnConflictClause::_internal_target_list(int index) const { return _impl_.target_list_.Get(index); } inline const ::pg_query::Node& OnConflictClause::target_list(int index) const { // @@protoc_insertion_point(field_get:pg_query.OnConflictClause.target_list) return _internal_target_list(index); } inline ::pg_query::Node* OnConflictClause::_internal_add_target_list() { return _impl_.target_list_.Add(); } inline ::pg_query::Node* OnConflictClause::add_target_list() { ::pg_query::Node* _add = _internal_add_target_list(); // @@protoc_insertion_point(field_add:pg_query.OnConflictClause.target_list) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& OnConflictClause::target_list() const { // @@protoc_insertion_point(field_list:pg_query.OnConflictClause.target_list) return _impl_.target_list_; } // .pg_query.Node where_clause = 4 [json_name = "whereClause"]; inline bool OnConflictClause::_internal_has_where_clause() const { return this != internal_default_instance() && _impl_.where_clause_ != nullptr; } inline bool OnConflictClause::has_where_clause() const { return _internal_has_where_clause(); } inline void OnConflictClause::clear_where_clause() { if (GetArenaForAllocation() == nullptr && _impl_.where_clause_ != nullptr) { delete _impl_.where_clause_; } _impl_.where_clause_ = nullptr; } inline const ::pg_query::Node& OnConflictClause::_internal_where_clause() const { const ::pg_query::Node* p = _impl_.where_clause_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& OnConflictClause::where_clause() const { // @@protoc_insertion_point(field_get:pg_query.OnConflictClause.where_clause) return _internal_where_clause(); } inline void OnConflictClause::unsafe_arena_set_allocated_where_clause( ::pg_query::Node* where_clause) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.where_clause_); } _impl_.where_clause_ = where_clause; if (where_clause) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.OnConflictClause.where_clause) } inline ::pg_query::Node* OnConflictClause::release_where_clause() { ::pg_query::Node* temp = _impl_.where_clause_; _impl_.where_clause_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* OnConflictClause::unsafe_arena_release_where_clause() { // @@protoc_insertion_point(field_release:pg_query.OnConflictClause.where_clause) ::pg_query::Node* temp = _impl_.where_clause_; _impl_.where_clause_ = nullptr; return temp; } inline ::pg_query::Node* OnConflictClause::_internal_mutable_where_clause() { if (_impl_.where_clause_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.where_clause_ = p; } return _impl_.where_clause_; } inline ::pg_query::Node* OnConflictClause::mutable_where_clause() { ::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* where_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.where_clause_; } if (where_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(where_clause); if (message_arena != submessage_arena) { where_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, where_clause, submessage_arena); } } else { } _impl_.where_clause_ = where_clause; // @@protoc_insertion_point(field_set_allocated:pg_query.OnConflictClause.where_clause) } // int32 location = 5 [json_name = "location"]; inline void OnConflictClause::clear_location() { _impl_.location_ = 0; } inline int32_t OnConflictClause::_internal_location() const { return _impl_.location_; } inline int32_t OnConflictClause::location() const { // @@protoc_insertion_point(field_get:pg_query.OnConflictClause.location) return _internal_location(); } inline void OnConflictClause::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void OnConflictClause::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.OnConflictClause.location) } // ------------------------------------------------------------------- // CTESearchClause // repeated .pg_query.Node search_col_list = 1 [json_name = "search_col_list"]; inline int CTESearchClause::_internal_search_col_list_size() const { return _impl_.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() { _impl_.search_col_list_.Clear(); } inline ::pg_query::Node* CTESearchClause::mutable_search_col_list(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CTESearchClause.search_col_list) return _impl_.search_col_list_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CTESearchClause::mutable_search_col_list() { // @@protoc_insertion_point(field_mutable_list:pg_query.CTESearchClause.search_col_list) return &_impl_.search_col_list_; } inline const ::pg_query::Node& CTESearchClause::_internal_search_col_list(int index) const { return _impl_.search_col_list_.Get(index); } inline const ::pg_query::Node& CTESearchClause::search_col_list(int index) const { // @@protoc_insertion_point(field_get:pg_query.CTESearchClause.search_col_list) return _internal_search_col_list(index); } inline ::pg_query::Node* CTESearchClause::_internal_add_search_col_list() { return _impl_.search_col_list_.Add(); } inline ::pg_query::Node* CTESearchClause::add_search_col_list() { ::pg_query::Node* _add = _internal_add_search_col_list(); // @@protoc_insertion_point(field_add:pg_query.CTESearchClause.search_col_list) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CTESearchClause::search_col_list() const { // @@protoc_insertion_point(field_list:pg_query.CTESearchClause.search_col_list) return _impl_.search_col_list_; } // bool search_breadth_first = 2 [json_name = "search_breadth_first"]; inline void CTESearchClause::clear_search_breadth_first() { _impl_.search_breadth_first_ = false; } inline bool CTESearchClause::_internal_search_breadth_first() const { return _impl_.search_breadth_first_; } 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::_internal_set_search_breadth_first(bool value) { _impl_.search_breadth_first_ = value; } 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) } // string search_seq_column = 3 [json_name = "search_seq_column"]; inline void CTESearchClause::clear_search_seq_column() { _impl_.search_seq_column_.ClearToEmpty(); } inline const std::string& CTESearchClause::search_seq_column() const { // @@protoc_insertion_point(field_get:pg_query.CTESearchClause.search_seq_column) return _internal_search_seq_column(); } template inline PROTOBUF_ALWAYS_INLINE void CTESearchClause::set_search_seq_column(ArgT0&& arg0, ArgT... args) { _impl_.search_seq_column_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CTESearchClause.search_seq_column) } inline std::string* CTESearchClause::mutable_search_seq_column() { 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 { return _impl_.search_seq_column_.Get(); } inline void CTESearchClause::_internal_set_search_seq_column(const std::string& value) { _impl_.search_seq_column_.Set(value, GetArenaForAllocation()); } inline std::string* CTESearchClause::_internal_mutable_search_seq_column() { return _impl_.search_seq_column_.Mutable(GetArenaForAllocation()); } inline std::string* CTESearchClause::release_search_seq_column() { // @@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* search_seq_column) { if (search_seq_column != nullptr) { } else { } _impl_.search_seq_column_.SetAllocated(search_seq_column, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.search_seq_column_.IsDefault()) { _impl_.search_seq_column_.Set("", GetArenaForAllocation()); } #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() { _impl_.location_ = 0; } inline int32_t CTESearchClause::_internal_location() const { return _impl_.location_; } inline int32_t CTESearchClause::location() const { // @@protoc_insertion_point(field_get:pg_query.CTESearchClause.location) return _internal_location(); } inline void CTESearchClause::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void CTESearchClause::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.CTESearchClause.location) } // ------------------------------------------------------------------- // CTECycleClause // repeated .pg_query.Node cycle_col_list = 1 [json_name = "cycle_col_list"]; inline int CTECycleClause::_internal_cycle_col_list_size() const { return _impl_.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() { _impl_.cycle_col_list_.Clear(); } inline ::pg_query::Node* CTECycleClause::mutable_cycle_col_list(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CTECycleClause.cycle_col_list) return _impl_.cycle_col_list_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CTECycleClause::mutable_cycle_col_list() { // @@protoc_insertion_point(field_mutable_list:pg_query.CTECycleClause.cycle_col_list) return &_impl_.cycle_col_list_; } inline const ::pg_query::Node& CTECycleClause::_internal_cycle_col_list(int index) const { return _impl_.cycle_col_list_.Get(index); } inline const ::pg_query::Node& CTECycleClause::cycle_col_list(int index) const { // @@protoc_insertion_point(field_get:pg_query.CTECycleClause.cycle_col_list) return _internal_cycle_col_list(index); } inline ::pg_query::Node* CTECycleClause::_internal_add_cycle_col_list() { return _impl_.cycle_col_list_.Add(); } inline ::pg_query::Node* CTECycleClause::add_cycle_col_list() { ::pg_query::Node* _add = _internal_add_cycle_col_list(); // @@protoc_insertion_point(field_add:pg_query.CTECycleClause.cycle_col_list) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CTECycleClause::cycle_col_list() const { // @@protoc_insertion_point(field_list:pg_query.CTECycleClause.cycle_col_list) return _impl_.cycle_col_list_; } // string cycle_mark_column = 2 [json_name = "cycle_mark_column"]; inline void CTECycleClause::clear_cycle_mark_column() { _impl_.cycle_mark_column_.ClearToEmpty(); } inline const std::string& CTECycleClause::cycle_mark_column() const { // @@protoc_insertion_point(field_get:pg_query.CTECycleClause.cycle_mark_column) return _internal_cycle_mark_column(); } template inline PROTOBUF_ALWAYS_INLINE void CTECycleClause::set_cycle_mark_column(ArgT0&& arg0, ArgT... args) { _impl_.cycle_mark_column_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CTECycleClause.cycle_mark_column) } inline std::string* CTECycleClause::mutable_cycle_mark_column() { 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 { return _impl_.cycle_mark_column_.Get(); } inline void CTECycleClause::_internal_set_cycle_mark_column(const std::string& value) { _impl_.cycle_mark_column_.Set(value, GetArenaForAllocation()); } inline std::string* CTECycleClause::_internal_mutable_cycle_mark_column() { return _impl_.cycle_mark_column_.Mutable(GetArenaForAllocation()); } inline std::string* CTECycleClause::release_cycle_mark_column() { // @@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* cycle_mark_column) { if (cycle_mark_column != nullptr) { } else { } _impl_.cycle_mark_column_.SetAllocated(cycle_mark_column, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.cycle_mark_column_.IsDefault()) { _impl_.cycle_mark_column_.Set("", GetArenaForAllocation()); } #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::_internal_has_cycle_mark_value() const { return this != internal_default_instance() && _impl_.cycle_mark_value_ != nullptr; } inline bool CTECycleClause::has_cycle_mark_value() const { return _internal_has_cycle_mark_value(); } inline void CTECycleClause::clear_cycle_mark_value() { if (GetArenaForAllocation() == nullptr && _impl_.cycle_mark_value_ != nullptr) { delete _impl_.cycle_mark_value_; } _impl_.cycle_mark_value_ = nullptr; } inline const ::pg_query::Node& CTECycleClause::_internal_cycle_mark_value() const { const ::pg_query::Node* p = _impl_.cycle_mark_value_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& CTECycleClause::cycle_mark_value() const { // @@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* cycle_mark_value) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cycle_mark_value_); } _impl_.cycle_mark_value_ = cycle_mark_value; if (cycle_mark_value) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CTECycleClause.cycle_mark_value) } inline ::pg_query::Node* CTECycleClause::release_cycle_mark_value() { ::pg_query::Node* temp = _impl_.cycle_mark_value_; _impl_.cycle_mark_value_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* CTECycleClause::unsafe_arena_release_cycle_mark_value() { // @@protoc_insertion_point(field_release:pg_query.CTECycleClause.cycle_mark_value) ::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() { if (_impl_.cycle_mark_value_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.cycle_mark_value_ = p; } return _impl_.cycle_mark_value_; } inline ::pg_query::Node* CTECycleClause::mutable_cycle_mark_value() { ::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* cycle_mark_value) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.cycle_mark_value_; } if (cycle_mark_value) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(cycle_mark_value); if (message_arena != submessage_arena) { cycle_mark_value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, cycle_mark_value, submessage_arena); } } else { } _impl_.cycle_mark_value_ = cycle_mark_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::_internal_has_cycle_mark_default() const { return this != internal_default_instance() && _impl_.cycle_mark_default_ != nullptr; } inline bool CTECycleClause::has_cycle_mark_default() const { return _internal_has_cycle_mark_default(); } inline void CTECycleClause::clear_cycle_mark_default() { if (GetArenaForAllocation() == nullptr && _impl_.cycle_mark_default_ != nullptr) { delete _impl_.cycle_mark_default_; } _impl_.cycle_mark_default_ = nullptr; } inline const ::pg_query::Node& CTECycleClause::_internal_cycle_mark_default() const { const ::pg_query::Node* p = _impl_.cycle_mark_default_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& CTECycleClause::cycle_mark_default() const { // @@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* cycle_mark_default) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cycle_mark_default_); } _impl_.cycle_mark_default_ = cycle_mark_default; if (cycle_mark_default) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CTECycleClause.cycle_mark_default) } inline ::pg_query::Node* CTECycleClause::release_cycle_mark_default() { ::pg_query::Node* temp = _impl_.cycle_mark_default_; _impl_.cycle_mark_default_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* CTECycleClause::unsafe_arena_release_cycle_mark_default() { // @@protoc_insertion_point(field_release:pg_query.CTECycleClause.cycle_mark_default) ::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() { if (_impl_.cycle_mark_default_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.cycle_mark_default_ = p; } return _impl_.cycle_mark_default_; } inline ::pg_query::Node* CTECycleClause::mutable_cycle_mark_default() { ::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* cycle_mark_default) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.cycle_mark_default_; } if (cycle_mark_default) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(cycle_mark_default); if (message_arena != submessage_arena) { cycle_mark_default = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, cycle_mark_default, submessage_arena); } } else { } _impl_.cycle_mark_default_ = cycle_mark_default; // @@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() { _impl_.cycle_path_column_.ClearToEmpty(); } inline const std::string& CTECycleClause::cycle_path_column() const { // @@protoc_insertion_point(field_get:pg_query.CTECycleClause.cycle_path_column) return _internal_cycle_path_column(); } template inline PROTOBUF_ALWAYS_INLINE void CTECycleClause::set_cycle_path_column(ArgT0&& arg0, ArgT... args) { _impl_.cycle_path_column_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CTECycleClause.cycle_path_column) } inline std::string* CTECycleClause::mutable_cycle_path_column() { 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 { return _impl_.cycle_path_column_.Get(); } inline void CTECycleClause::_internal_set_cycle_path_column(const std::string& value) { _impl_.cycle_path_column_.Set(value, GetArenaForAllocation()); } inline std::string* CTECycleClause::_internal_mutable_cycle_path_column() { return _impl_.cycle_path_column_.Mutable(GetArenaForAllocation()); } inline std::string* CTECycleClause::release_cycle_path_column() { // @@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* cycle_path_column) { if (cycle_path_column != nullptr) { } else { } _impl_.cycle_path_column_.SetAllocated(cycle_path_column, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.cycle_path_column_.IsDefault()) { _impl_.cycle_path_column_.Set("", GetArenaForAllocation()); } #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() { _impl_.location_ = 0; } inline int32_t CTECycleClause::_internal_location() const { return _impl_.location_; } inline int32_t CTECycleClause::location() const { // @@protoc_insertion_point(field_get:pg_query.CTECycleClause.location) return _internal_location(); } inline void CTECycleClause::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void CTECycleClause::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.CTECycleClause.location) } // uint32 cycle_mark_type = 7 [json_name = "cycle_mark_type"]; inline void CTECycleClause::clear_cycle_mark_type() { _impl_.cycle_mark_type_ = 0u; } inline uint32_t CTECycleClause::_internal_cycle_mark_type() const { return _impl_.cycle_mark_type_; } 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::_internal_set_cycle_mark_type(uint32_t value) { _impl_.cycle_mark_type_ = value; } 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) } // int32 cycle_mark_typmod = 8 [json_name = "cycle_mark_typmod"]; inline void CTECycleClause::clear_cycle_mark_typmod() { _impl_.cycle_mark_typmod_ = 0; } inline int32_t CTECycleClause::_internal_cycle_mark_typmod() const { return _impl_.cycle_mark_typmod_; } 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::_internal_set_cycle_mark_typmod(int32_t value) { _impl_.cycle_mark_typmod_ = value; } 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) } // uint32 cycle_mark_collation = 9 [json_name = "cycle_mark_collation"]; inline void CTECycleClause::clear_cycle_mark_collation() { _impl_.cycle_mark_collation_ = 0u; } inline uint32_t CTECycleClause::_internal_cycle_mark_collation() const { return _impl_.cycle_mark_collation_; } 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::_internal_set_cycle_mark_collation(uint32_t value) { _impl_.cycle_mark_collation_ = value; } 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) } // uint32 cycle_mark_neop = 10 [json_name = "cycle_mark_neop"]; inline void CTECycleClause::clear_cycle_mark_neop() { _impl_.cycle_mark_neop_ = 0u; } inline uint32_t CTECycleClause::_internal_cycle_mark_neop() const { return _impl_.cycle_mark_neop_; } 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::_internal_set_cycle_mark_neop(uint32_t value) { _impl_.cycle_mark_neop_ = value; } 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) } // ------------------------------------------------------------------- // CommonTableExpr // string ctename = 1 [json_name = "ctename"]; inline void CommonTableExpr::clear_ctename() { _impl_.ctename_.ClearToEmpty(); } inline const std::string& CommonTableExpr::ctename() const { // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.ctename) return _internal_ctename(); } template inline PROTOBUF_ALWAYS_INLINE void CommonTableExpr::set_ctename(ArgT0&& arg0, ArgT... args) { _impl_.ctename_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.CommonTableExpr.ctename) } inline std::string* CommonTableExpr::mutable_ctename() { 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 { return _impl_.ctename_.Get(); } inline void CommonTableExpr::_internal_set_ctename(const std::string& value) { _impl_.ctename_.Set(value, GetArenaForAllocation()); } inline std::string* CommonTableExpr::_internal_mutable_ctename() { return _impl_.ctename_.Mutable(GetArenaForAllocation()); } inline std::string* CommonTableExpr::release_ctename() { // @@protoc_insertion_point(field_release:pg_query.CommonTableExpr.ctename) return _impl_.ctename_.Release(); } inline void CommonTableExpr::set_allocated_ctename(std::string* ctename) { if (ctename != nullptr) { } else { } _impl_.ctename_.SetAllocated(ctename, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.ctename_.IsDefault()) { _impl_.ctename_.Set("", GetArenaForAllocation()); } #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 _impl_.aliascolnames_.size(); } inline int CommonTableExpr::aliascolnames_size() const { return _internal_aliascolnames_size(); } inline void CommonTableExpr::clear_aliascolnames() { _impl_.aliascolnames_.Clear(); } inline ::pg_query::Node* CommonTableExpr::mutable_aliascolnames(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CommonTableExpr.aliascolnames) return _impl_.aliascolnames_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CommonTableExpr::mutable_aliascolnames() { // @@protoc_insertion_point(field_mutable_list:pg_query.CommonTableExpr.aliascolnames) return &_impl_.aliascolnames_; } inline const ::pg_query::Node& CommonTableExpr::_internal_aliascolnames(int index) const { return _impl_.aliascolnames_.Get(index); } inline const ::pg_query::Node& CommonTableExpr::aliascolnames(int index) const { // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.aliascolnames) return _internal_aliascolnames(index); } inline ::pg_query::Node* CommonTableExpr::_internal_add_aliascolnames() { return _impl_.aliascolnames_.Add(); } inline ::pg_query::Node* CommonTableExpr::add_aliascolnames() { ::pg_query::Node* _add = _internal_add_aliascolnames(); // @@protoc_insertion_point(field_add:pg_query.CommonTableExpr.aliascolnames) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CommonTableExpr::aliascolnames() const { // @@protoc_insertion_point(field_list:pg_query.CommonTableExpr.aliascolnames) return _impl_.aliascolnames_; } // .pg_query.CTEMaterialize ctematerialized = 3 [json_name = "ctematerialized"]; inline void CommonTableExpr::clear_ctematerialized() { _impl_.ctematerialized_ = 0; } inline ::pg_query::CTEMaterialize CommonTableExpr::_internal_ctematerialized() const { return static_cast< ::pg_query::CTEMaterialize >(_impl_.ctematerialized_); } inline ::pg_query::CTEMaterialize CommonTableExpr::ctematerialized() const { // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.ctematerialized) return _internal_ctematerialized(); } inline void CommonTableExpr::_internal_set_ctematerialized(::pg_query::CTEMaterialize value) { _impl_.ctematerialized_ = value; } inline void CommonTableExpr::set_ctematerialized(::pg_query::CTEMaterialize value) { _internal_set_ctematerialized(value); // @@protoc_insertion_point(field_set:pg_query.CommonTableExpr.ctematerialized) } // .pg_query.Node ctequery = 4 [json_name = "ctequery"]; inline bool CommonTableExpr::_internal_has_ctequery() const { return this != internal_default_instance() && _impl_.ctequery_ != nullptr; } inline bool CommonTableExpr::has_ctequery() const { return _internal_has_ctequery(); } inline void CommonTableExpr::clear_ctequery() { if (GetArenaForAllocation() == nullptr && _impl_.ctequery_ != nullptr) { delete _impl_.ctequery_; } _impl_.ctequery_ = nullptr; } inline const ::pg_query::Node& CommonTableExpr::_internal_ctequery() const { const ::pg_query::Node* p = _impl_.ctequery_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& CommonTableExpr::ctequery() const { // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.ctequery) return _internal_ctequery(); } inline void CommonTableExpr::unsafe_arena_set_allocated_ctequery( ::pg_query::Node* ctequery) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.ctequery_); } _impl_.ctequery_ = ctequery; if (ctequery) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CommonTableExpr.ctequery) } inline ::pg_query::Node* CommonTableExpr::release_ctequery() { ::pg_query::Node* temp = _impl_.ctequery_; _impl_.ctequery_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* CommonTableExpr::unsafe_arena_release_ctequery() { // @@protoc_insertion_point(field_release:pg_query.CommonTableExpr.ctequery) ::pg_query::Node* temp = _impl_.ctequery_; _impl_.ctequery_ = nullptr; return temp; } inline ::pg_query::Node* CommonTableExpr::_internal_mutable_ctequery() { if (_impl_.ctequery_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.ctequery_ = p; } return _impl_.ctequery_; } inline ::pg_query::Node* CommonTableExpr::mutable_ctequery() { ::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* ctequery) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.ctequery_; } if (ctequery) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(ctequery); if (message_arena != submessage_arena) { ctequery = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, ctequery, submessage_arena); } } else { } _impl_.ctequery_ = ctequery; // @@protoc_insertion_point(field_set_allocated:pg_query.CommonTableExpr.ctequery) } // .pg_query.CTESearchClause search_clause = 5 [json_name = "search_clause"]; inline bool CommonTableExpr::_internal_has_search_clause() const { return this != internal_default_instance() && _impl_.search_clause_ != nullptr; } inline bool CommonTableExpr::has_search_clause() const { return _internal_has_search_clause(); } inline void CommonTableExpr::clear_search_clause() { if (GetArenaForAllocation() == nullptr && _impl_.search_clause_ != nullptr) { delete _impl_.search_clause_; } _impl_.search_clause_ = nullptr; } inline const ::pg_query::CTESearchClause& CommonTableExpr::_internal_search_clause() const { const ::pg_query::CTESearchClause* p = _impl_.search_clause_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_CTESearchClause_default_instance_); } inline const ::pg_query::CTESearchClause& CommonTableExpr::search_clause() const { // @@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* search_clause) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.search_clause_); } _impl_.search_clause_ = search_clause; if (search_clause) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CommonTableExpr.search_clause) } inline ::pg_query::CTESearchClause* CommonTableExpr::release_search_clause() { ::pg_query::CTESearchClause* temp = _impl_.search_clause_; _impl_.search_clause_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::CTESearchClause* CommonTableExpr::unsafe_arena_release_search_clause() { // @@protoc_insertion_point(field_release:pg_query.CommonTableExpr.search_clause) ::pg_query::CTESearchClause* temp = _impl_.search_clause_; _impl_.search_clause_ = nullptr; return temp; } inline ::pg_query::CTESearchClause* CommonTableExpr::_internal_mutable_search_clause() { if (_impl_.search_clause_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::CTESearchClause>(GetArenaForAllocation()); _impl_.search_clause_ = p; } return _impl_.search_clause_; } inline ::pg_query::CTESearchClause* CommonTableExpr::mutable_search_clause() { ::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* search_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.search_clause_; } if (search_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(search_clause); if (message_arena != submessage_arena) { search_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, search_clause, submessage_arena); } } else { } _impl_.search_clause_ = search_clause; // @@protoc_insertion_point(field_set_allocated:pg_query.CommonTableExpr.search_clause) } // .pg_query.CTECycleClause cycle_clause = 6 [json_name = "cycle_clause"]; inline bool CommonTableExpr::_internal_has_cycle_clause() const { return this != internal_default_instance() && _impl_.cycle_clause_ != nullptr; } inline bool CommonTableExpr::has_cycle_clause() const { return _internal_has_cycle_clause(); } inline void CommonTableExpr::clear_cycle_clause() { if (GetArenaForAllocation() == nullptr && _impl_.cycle_clause_ != nullptr) { delete _impl_.cycle_clause_; } _impl_.cycle_clause_ = nullptr; } inline const ::pg_query::CTECycleClause& CommonTableExpr::_internal_cycle_clause() const { const ::pg_query::CTECycleClause* p = _impl_.cycle_clause_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_CTECycleClause_default_instance_); } inline const ::pg_query::CTECycleClause& CommonTableExpr::cycle_clause() const { // @@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* cycle_clause) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cycle_clause_); } _impl_.cycle_clause_ = cycle_clause; if (cycle_clause) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.CommonTableExpr.cycle_clause) } inline ::pg_query::CTECycleClause* CommonTableExpr::release_cycle_clause() { ::pg_query::CTECycleClause* temp = _impl_.cycle_clause_; _impl_.cycle_clause_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::CTECycleClause* CommonTableExpr::unsafe_arena_release_cycle_clause() { // @@protoc_insertion_point(field_release:pg_query.CommonTableExpr.cycle_clause) ::pg_query::CTECycleClause* temp = _impl_.cycle_clause_; _impl_.cycle_clause_ = nullptr; return temp; } inline ::pg_query::CTECycleClause* CommonTableExpr::_internal_mutable_cycle_clause() { if (_impl_.cycle_clause_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::CTECycleClause>(GetArenaForAllocation()); _impl_.cycle_clause_ = p; } return _impl_.cycle_clause_; } inline ::pg_query::CTECycleClause* CommonTableExpr::mutable_cycle_clause() { ::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* cycle_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.cycle_clause_; } if (cycle_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(cycle_clause); if (message_arena != submessage_arena) { cycle_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, cycle_clause, submessage_arena); } } else { } _impl_.cycle_clause_ = cycle_clause; // @@protoc_insertion_point(field_set_allocated:pg_query.CommonTableExpr.cycle_clause) } // int32 location = 7 [json_name = "location"]; inline void CommonTableExpr::clear_location() { _impl_.location_ = 0; } inline int32_t CommonTableExpr::_internal_location() const { return _impl_.location_; } inline int32_t CommonTableExpr::location() const { // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.location) return _internal_location(); } inline void CommonTableExpr::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void CommonTableExpr::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.CommonTableExpr.location) } // bool cterecursive = 8 [json_name = "cterecursive"]; inline void CommonTableExpr::clear_cterecursive() { _impl_.cterecursive_ = false; } inline bool CommonTableExpr::_internal_cterecursive() const { return _impl_.cterecursive_; } inline bool CommonTableExpr::cterecursive() const { // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.cterecursive) return _internal_cterecursive(); } inline void CommonTableExpr::_internal_set_cterecursive(bool value) { _impl_.cterecursive_ = value; } inline void CommonTableExpr::set_cterecursive(bool value) { _internal_set_cterecursive(value); // @@protoc_insertion_point(field_set:pg_query.CommonTableExpr.cterecursive) } // int32 cterefcount = 9 [json_name = "cterefcount"]; inline void CommonTableExpr::clear_cterefcount() { _impl_.cterefcount_ = 0; } inline int32_t CommonTableExpr::_internal_cterefcount() const { return _impl_.cterefcount_; } inline int32_t CommonTableExpr::cterefcount() const { // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.cterefcount) return _internal_cterefcount(); } inline void CommonTableExpr::_internal_set_cterefcount(int32_t value) { _impl_.cterefcount_ = value; } inline void CommonTableExpr::set_cterefcount(int32_t value) { _internal_set_cterefcount(value); // @@protoc_insertion_point(field_set:pg_query.CommonTableExpr.cterefcount) } // repeated .pg_query.Node ctecolnames = 10 [json_name = "ctecolnames"]; inline int CommonTableExpr::_internal_ctecolnames_size() const { return _impl_.ctecolnames_.size(); } inline int CommonTableExpr::ctecolnames_size() const { return _internal_ctecolnames_size(); } inline void CommonTableExpr::clear_ctecolnames() { _impl_.ctecolnames_.Clear(); } inline ::pg_query::Node* CommonTableExpr::mutable_ctecolnames(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CommonTableExpr.ctecolnames) return _impl_.ctecolnames_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CommonTableExpr::mutable_ctecolnames() { // @@protoc_insertion_point(field_mutable_list:pg_query.CommonTableExpr.ctecolnames) return &_impl_.ctecolnames_; } inline const ::pg_query::Node& CommonTableExpr::_internal_ctecolnames(int index) const { return _impl_.ctecolnames_.Get(index); } inline const ::pg_query::Node& CommonTableExpr::ctecolnames(int index) const { // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.ctecolnames) return _internal_ctecolnames(index); } inline ::pg_query::Node* CommonTableExpr::_internal_add_ctecolnames() { return _impl_.ctecolnames_.Add(); } inline ::pg_query::Node* CommonTableExpr::add_ctecolnames() { ::pg_query::Node* _add = _internal_add_ctecolnames(); // @@protoc_insertion_point(field_add:pg_query.CommonTableExpr.ctecolnames) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CommonTableExpr::ctecolnames() const { // @@protoc_insertion_point(field_list:pg_query.CommonTableExpr.ctecolnames) return _impl_.ctecolnames_; } // repeated .pg_query.Node ctecoltypes = 11 [json_name = "ctecoltypes"]; inline int CommonTableExpr::_internal_ctecoltypes_size() const { return _impl_.ctecoltypes_.size(); } inline int CommonTableExpr::ctecoltypes_size() const { return _internal_ctecoltypes_size(); } inline void CommonTableExpr::clear_ctecoltypes() { _impl_.ctecoltypes_.Clear(); } inline ::pg_query::Node* CommonTableExpr::mutable_ctecoltypes(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CommonTableExpr.ctecoltypes) return _impl_.ctecoltypes_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CommonTableExpr::mutable_ctecoltypes() { // @@protoc_insertion_point(field_mutable_list:pg_query.CommonTableExpr.ctecoltypes) return &_impl_.ctecoltypes_; } inline const ::pg_query::Node& CommonTableExpr::_internal_ctecoltypes(int index) const { return _impl_.ctecoltypes_.Get(index); } inline const ::pg_query::Node& CommonTableExpr::ctecoltypes(int index) const { // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.ctecoltypes) return _internal_ctecoltypes(index); } inline ::pg_query::Node* CommonTableExpr::_internal_add_ctecoltypes() { return _impl_.ctecoltypes_.Add(); } inline ::pg_query::Node* CommonTableExpr::add_ctecoltypes() { ::pg_query::Node* _add = _internal_add_ctecoltypes(); // @@protoc_insertion_point(field_add:pg_query.CommonTableExpr.ctecoltypes) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CommonTableExpr::ctecoltypes() const { // @@protoc_insertion_point(field_list:pg_query.CommonTableExpr.ctecoltypes) return _impl_.ctecoltypes_; } // repeated .pg_query.Node ctecoltypmods = 12 [json_name = "ctecoltypmods"]; inline int CommonTableExpr::_internal_ctecoltypmods_size() const { return _impl_.ctecoltypmods_.size(); } inline int CommonTableExpr::ctecoltypmods_size() const { return _internal_ctecoltypmods_size(); } inline void CommonTableExpr::clear_ctecoltypmods() { _impl_.ctecoltypmods_.Clear(); } inline ::pg_query::Node* CommonTableExpr::mutable_ctecoltypmods(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CommonTableExpr.ctecoltypmods) return _impl_.ctecoltypmods_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CommonTableExpr::mutable_ctecoltypmods() { // @@protoc_insertion_point(field_mutable_list:pg_query.CommonTableExpr.ctecoltypmods) return &_impl_.ctecoltypmods_; } inline const ::pg_query::Node& CommonTableExpr::_internal_ctecoltypmods(int index) const { return _impl_.ctecoltypmods_.Get(index); } inline const ::pg_query::Node& CommonTableExpr::ctecoltypmods(int index) const { // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.ctecoltypmods) return _internal_ctecoltypmods(index); } inline ::pg_query::Node* CommonTableExpr::_internal_add_ctecoltypmods() { return _impl_.ctecoltypmods_.Add(); } inline ::pg_query::Node* CommonTableExpr::add_ctecoltypmods() { ::pg_query::Node* _add = _internal_add_ctecoltypmods(); // @@protoc_insertion_point(field_add:pg_query.CommonTableExpr.ctecoltypmods) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CommonTableExpr::ctecoltypmods() const { // @@protoc_insertion_point(field_list:pg_query.CommonTableExpr.ctecoltypmods) return _impl_.ctecoltypmods_; } // repeated .pg_query.Node ctecolcollations = 13 [json_name = "ctecolcollations"]; inline int CommonTableExpr::_internal_ctecolcollations_size() const { return _impl_.ctecolcollations_.size(); } inline int CommonTableExpr::ctecolcollations_size() const { return _internal_ctecolcollations_size(); } inline void CommonTableExpr::clear_ctecolcollations() { _impl_.ctecolcollations_.Clear(); } inline ::pg_query::Node* CommonTableExpr::mutable_ctecolcollations(int index) { // @@protoc_insertion_point(field_mutable:pg_query.CommonTableExpr.ctecolcollations) return _impl_.ctecolcollations_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* CommonTableExpr::mutable_ctecolcollations() { // @@protoc_insertion_point(field_mutable_list:pg_query.CommonTableExpr.ctecolcollations) return &_impl_.ctecolcollations_; } inline const ::pg_query::Node& CommonTableExpr::_internal_ctecolcollations(int index) const { return _impl_.ctecolcollations_.Get(index); } inline const ::pg_query::Node& CommonTableExpr::ctecolcollations(int index) const { // @@protoc_insertion_point(field_get:pg_query.CommonTableExpr.ctecolcollations) return _internal_ctecolcollations(index); } inline ::pg_query::Node* CommonTableExpr::_internal_add_ctecolcollations() { return _impl_.ctecolcollations_.Add(); } inline ::pg_query::Node* CommonTableExpr::add_ctecolcollations() { ::pg_query::Node* _add = _internal_add_ctecolcollations(); // @@protoc_insertion_point(field_add:pg_query.CommonTableExpr.ctecolcollations) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& CommonTableExpr::ctecolcollations() const { // @@protoc_insertion_point(field_list:pg_query.CommonTableExpr.ctecolcollations) return _impl_.ctecolcollations_; } // ------------------------------------------------------------------- // MergeWhenClause // bool matched = 1 [json_name = "matched"]; inline void MergeWhenClause::clear_matched() { _impl_.matched_ = false; } inline bool MergeWhenClause::_internal_matched() const { return _impl_.matched_; } inline bool MergeWhenClause::matched() const { // @@protoc_insertion_point(field_get:pg_query.MergeWhenClause.matched) return _internal_matched(); } inline void MergeWhenClause::_internal_set_matched(bool value) { _impl_.matched_ = value; } inline void MergeWhenClause::set_matched(bool value) { _internal_set_matched(value); // @@protoc_insertion_point(field_set:pg_query.MergeWhenClause.matched) } // .pg_query.CmdType command_type = 2 [json_name = "commandType"]; inline void MergeWhenClause::clear_command_type() { _impl_.command_type_ = 0; } inline ::pg_query::CmdType MergeWhenClause::_internal_command_type() const { return static_cast< ::pg_query::CmdType >(_impl_.command_type_); } 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::_internal_set_command_type(::pg_query::CmdType value) { _impl_.command_type_ = value; } 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) } // .pg_query.OverridingKind override = 3 [json_name = "override"]; inline void MergeWhenClause::clear_override() { _impl_.override_ = 0; } inline ::pg_query::OverridingKind MergeWhenClause::_internal_override() const { return static_cast< ::pg_query::OverridingKind >(_impl_.override_); } inline ::pg_query::OverridingKind MergeWhenClause::override() const { // @@protoc_insertion_point(field_get:pg_query.MergeWhenClause.override) return _internal_override(); } inline void MergeWhenClause::_internal_set_override(::pg_query::OverridingKind value) { _impl_.override_ = value; } inline void MergeWhenClause::set_override(::pg_query::OverridingKind value) { _internal_set_override(value); // @@protoc_insertion_point(field_set:pg_query.MergeWhenClause.override) } // .pg_query.Node condition = 4 [json_name = "condition"]; inline bool MergeWhenClause::_internal_has_condition() const { return this != internal_default_instance() && _impl_.condition_ != nullptr; } inline bool MergeWhenClause::has_condition() const { return _internal_has_condition(); } inline void MergeWhenClause::clear_condition() { if (GetArenaForAllocation() == nullptr && _impl_.condition_ != nullptr) { delete _impl_.condition_; } _impl_.condition_ = nullptr; } inline const ::pg_query::Node& MergeWhenClause::_internal_condition() const { const ::pg_query::Node* p = _impl_.condition_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& MergeWhenClause::condition() const { // @@protoc_insertion_point(field_get:pg_query.MergeWhenClause.condition) return _internal_condition(); } inline void MergeWhenClause::unsafe_arena_set_allocated_condition( ::pg_query::Node* condition) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.condition_); } _impl_.condition_ = condition; if (condition) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.MergeWhenClause.condition) } inline ::pg_query::Node* MergeWhenClause::release_condition() { ::pg_query::Node* temp = _impl_.condition_; _impl_.condition_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* MergeWhenClause::unsafe_arena_release_condition() { // @@protoc_insertion_point(field_release:pg_query.MergeWhenClause.condition) ::pg_query::Node* temp = _impl_.condition_; _impl_.condition_ = nullptr; return temp; } inline ::pg_query::Node* MergeWhenClause::_internal_mutable_condition() { if (_impl_.condition_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.condition_ = p; } return _impl_.condition_; } inline ::pg_query::Node* MergeWhenClause::mutable_condition() { ::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* condition) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.condition_; } if (condition) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(condition); if (message_arena != submessage_arena) { condition = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, condition, submessage_arena); } } else { } _impl_.condition_ = condition; // @@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 _impl_.target_list_.size(); } inline int MergeWhenClause::target_list_size() const { return _internal_target_list_size(); } inline void MergeWhenClause::clear_target_list() { _impl_.target_list_.Clear(); } inline ::pg_query::Node* MergeWhenClause::mutable_target_list(int index) { // @@protoc_insertion_point(field_mutable:pg_query.MergeWhenClause.target_list) return _impl_.target_list_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* MergeWhenClause::mutable_target_list() { // @@protoc_insertion_point(field_mutable_list:pg_query.MergeWhenClause.target_list) return &_impl_.target_list_; } inline const ::pg_query::Node& MergeWhenClause::_internal_target_list(int index) const { return _impl_.target_list_.Get(index); } inline const ::pg_query::Node& MergeWhenClause::target_list(int index) const { // @@protoc_insertion_point(field_get:pg_query.MergeWhenClause.target_list) return _internal_target_list(index); } inline ::pg_query::Node* MergeWhenClause::_internal_add_target_list() { return _impl_.target_list_.Add(); } inline ::pg_query::Node* MergeWhenClause::add_target_list() { ::pg_query::Node* _add = _internal_add_target_list(); // @@protoc_insertion_point(field_add:pg_query.MergeWhenClause.target_list) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& MergeWhenClause::target_list() const { // @@protoc_insertion_point(field_list:pg_query.MergeWhenClause.target_list) return _impl_.target_list_; } // repeated .pg_query.Node values = 6 [json_name = "values"]; inline int MergeWhenClause::_internal_values_size() const { return _impl_.values_.size(); } inline int MergeWhenClause::values_size() const { return _internal_values_size(); } inline void MergeWhenClause::clear_values() { _impl_.values_.Clear(); } inline ::pg_query::Node* MergeWhenClause::mutable_values(int index) { // @@protoc_insertion_point(field_mutable:pg_query.MergeWhenClause.values) return _impl_.values_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* MergeWhenClause::mutable_values() { // @@protoc_insertion_point(field_mutable_list:pg_query.MergeWhenClause.values) return &_impl_.values_; } inline const ::pg_query::Node& MergeWhenClause::_internal_values(int index) const { return _impl_.values_.Get(index); } inline const ::pg_query::Node& MergeWhenClause::values(int index) const { // @@protoc_insertion_point(field_get:pg_query.MergeWhenClause.values) return _internal_values(index); } inline ::pg_query::Node* MergeWhenClause::_internal_add_values() { return _impl_.values_.Add(); } inline ::pg_query::Node* MergeWhenClause::add_values() { ::pg_query::Node* _add = _internal_add_values(); // @@protoc_insertion_point(field_add:pg_query.MergeWhenClause.values) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& MergeWhenClause::values() const { // @@protoc_insertion_point(field_list:pg_query.MergeWhenClause.values) return _impl_.values_; } // ------------------------------------------------------------------- // RoleSpec // .pg_query.RoleSpecType roletype = 1 [json_name = "roletype"]; inline void RoleSpec::clear_roletype() { _impl_.roletype_ = 0; } inline ::pg_query::RoleSpecType RoleSpec::_internal_roletype() const { return static_cast< ::pg_query::RoleSpecType >(_impl_.roletype_); } inline ::pg_query::RoleSpecType RoleSpec::roletype() const { // @@protoc_insertion_point(field_get:pg_query.RoleSpec.roletype) return _internal_roletype(); } inline void RoleSpec::_internal_set_roletype(::pg_query::RoleSpecType value) { _impl_.roletype_ = value; } inline void RoleSpec::set_roletype(::pg_query::RoleSpecType value) { _internal_set_roletype(value); // @@protoc_insertion_point(field_set:pg_query.RoleSpec.roletype) } // string rolename = 2 [json_name = "rolename"]; inline void RoleSpec::clear_rolename() { _impl_.rolename_.ClearToEmpty(); } inline const std::string& RoleSpec::rolename() const { // @@protoc_insertion_point(field_get:pg_query.RoleSpec.rolename) return _internal_rolename(); } template inline PROTOBUF_ALWAYS_INLINE void RoleSpec::set_rolename(ArgT0&& arg0, ArgT... args) { _impl_.rolename_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.RoleSpec.rolename) } inline std::string* RoleSpec::mutable_rolename() { 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 { return _impl_.rolename_.Get(); } inline void RoleSpec::_internal_set_rolename(const std::string& value) { _impl_.rolename_.Set(value, GetArenaForAllocation()); } inline std::string* RoleSpec::_internal_mutable_rolename() { return _impl_.rolename_.Mutable(GetArenaForAllocation()); } inline std::string* RoleSpec::release_rolename() { // @@protoc_insertion_point(field_release:pg_query.RoleSpec.rolename) return _impl_.rolename_.Release(); } inline void RoleSpec::set_allocated_rolename(std::string* rolename) { if (rolename != nullptr) { } else { } _impl_.rolename_.SetAllocated(rolename, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.rolename_.IsDefault()) { _impl_.rolename_.Set("", GetArenaForAllocation()); } #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() { _impl_.location_ = 0; } inline int32_t RoleSpec::_internal_location() const { return _impl_.location_; } inline int32_t RoleSpec::location() const { // @@protoc_insertion_point(field_get:pg_query.RoleSpec.location) return _internal_location(); } inline void RoleSpec::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void RoleSpec::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.RoleSpec.location) } // ------------------------------------------------------------------- // TriggerTransition // string name = 1 [json_name = "name"]; inline void TriggerTransition::clear_name() { _impl_.name_.ClearToEmpty(); } inline const std::string& TriggerTransition::name() const { // @@protoc_insertion_point(field_get:pg_query.TriggerTransition.name) return _internal_name(); } template inline PROTOBUF_ALWAYS_INLINE void TriggerTransition::set_name(ArgT0&& arg0, ArgT... args) { _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.TriggerTransition.name) } inline std::string* TriggerTransition::mutable_name() { 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 { return _impl_.name_.Get(); } inline void TriggerTransition::_internal_set_name(const std::string& value) { _impl_.name_.Set(value, GetArenaForAllocation()); } inline std::string* TriggerTransition::_internal_mutable_name() { return _impl_.name_.Mutable(GetArenaForAllocation()); } inline std::string* TriggerTransition::release_name() { // @@protoc_insertion_point(field_release:pg_query.TriggerTransition.name) return _impl_.name_.Release(); } inline void TriggerTransition::set_allocated_name(std::string* name) { if (name != nullptr) { } else { } _impl_.name_.SetAllocated(name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.name_.IsDefault()) { _impl_.name_.Set("", GetArenaForAllocation()); } #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() { _impl_.is_new_ = false; } inline bool TriggerTransition::_internal_is_new() const { return _impl_.is_new_; } inline bool TriggerTransition::is_new() const { // @@protoc_insertion_point(field_get:pg_query.TriggerTransition.is_new) return _internal_is_new(); } inline void TriggerTransition::_internal_set_is_new(bool value) { _impl_.is_new_ = value; } inline void TriggerTransition::set_is_new(bool value) { _internal_set_is_new(value); // @@protoc_insertion_point(field_set:pg_query.TriggerTransition.is_new) } // bool is_table = 3 [json_name = "isTable"]; inline void TriggerTransition::clear_is_table() { _impl_.is_table_ = false; } inline bool TriggerTransition::_internal_is_table() const { return _impl_.is_table_; } inline bool TriggerTransition::is_table() const { // @@protoc_insertion_point(field_get:pg_query.TriggerTransition.is_table) return _internal_is_table(); } inline void TriggerTransition::_internal_set_is_table(bool value) { _impl_.is_table_ = value; } inline void TriggerTransition::set_is_table(bool value) { _internal_set_is_table(value); // @@protoc_insertion_point(field_set:pg_query.TriggerTransition.is_table) } // ------------------------------------------------------------------- // PartitionElem // string name = 1 [json_name = "name"]; inline void PartitionElem::clear_name() { _impl_.name_.ClearToEmpty(); } inline const std::string& PartitionElem::name() const { // @@protoc_insertion_point(field_get:pg_query.PartitionElem.name) return _internal_name(); } template inline PROTOBUF_ALWAYS_INLINE void PartitionElem::set_name(ArgT0&& arg0, ArgT... args) { _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.PartitionElem.name) } inline std::string* PartitionElem::mutable_name() { 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 { return _impl_.name_.Get(); } inline void PartitionElem::_internal_set_name(const std::string& value) { _impl_.name_.Set(value, GetArenaForAllocation()); } inline std::string* PartitionElem::_internal_mutable_name() { return _impl_.name_.Mutable(GetArenaForAllocation()); } inline std::string* PartitionElem::release_name() { // @@protoc_insertion_point(field_release:pg_query.PartitionElem.name) return _impl_.name_.Release(); } inline void PartitionElem::set_allocated_name(std::string* name) { if (name != nullptr) { } else { } _impl_.name_.SetAllocated(name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.name_.IsDefault()) { _impl_.name_.Set("", GetArenaForAllocation()); } #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::_internal_has_expr() const { return this != internal_default_instance() && _impl_.expr_ != nullptr; } inline bool PartitionElem::has_expr() const { return _internal_has_expr(); } inline void PartitionElem::clear_expr() { if (GetArenaForAllocation() == nullptr && _impl_.expr_ != nullptr) { delete _impl_.expr_; } _impl_.expr_ = nullptr; } inline const ::pg_query::Node& PartitionElem::_internal_expr() const { const ::pg_query::Node* p = _impl_.expr_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& PartitionElem::expr() const { // @@protoc_insertion_point(field_get:pg_query.PartitionElem.expr) return _internal_expr(); } inline void PartitionElem::unsafe_arena_set_allocated_expr( ::pg_query::Node* expr) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.expr_); } _impl_.expr_ = expr; if (expr) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.PartitionElem.expr) } inline ::pg_query::Node* PartitionElem::release_expr() { ::pg_query::Node* temp = _impl_.expr_; _impl_.expr_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* PartitionElem::unsafe_arena_release_expr() { // @@protoc_insertion_point(field_release:pg_query.PartitionElem.expr) ::pg_query::Node* temp = _impl_.expr_; _impl_.expr_ = nullptr; return temp; } inline ::pg_query::Node* PartitionElem::_internal_mutable_expr() { if (_impl_.expr_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.expr_ = p; } return _impl_.expr_; } inline ::pg_query::Node* PartitionElem::mutable_expr() { ::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* expr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.expr_; } if (expr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(expr); if (message_arena != submessage_arena) { expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, expr, submessage_arena); } } else { } _impl_.expr_ = expr; // @@protoc_insertion_point(field_set_allocated:pg_query.PartitionElem.expr) } // repeated .pg_query.Node collation = 3 [json_name = "collation"]; inline int PartitionElem::_internal_collation_size() const { return _impl_.collation_.size(); } inline int PartitionElem::collation_size() const { return _internal_collation_size(); } inline void PartitionElem::clear_collation() { _impl_.collation_.Clear(); } inline ::pg_query::Node* PartitionElem::mutable_collation(int index) { // @@protoc_insertion_point(field_mutable:pg_query.PartitionElem.collation) return _impl_.collation_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* PartitionElem::mutable_collation() { // @@protoc_insertion_point(field_mutable_list:pg_query.PartitionElem.collation) return &_impl_.collation_; } inline const ::pg_query::Node& PartitionElem::_internal_collation(int index) const { return _impl_.collation_.Get(index); } inline const ::pg_query::Node& PartitionElem::collation(int index) const { // @@protoc_insertion_point(field_get:pg_query.PartitionElem.collation) return _internal_collation(index); } inline ::pg_query::Node* PartitionElem::_internal_add_collation() { return _impl_.collation_.Add(); } inline ::pg_query::Node* PartitionElem::add_collation() { ::pg_query::Node* _add = _internal_add_collation(); // @@protoc_insertion_point(field_add:pg_query.PartitionElem.collation) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& PartitionElem::collation() const { // @@protoc_insertion_point(field_list:pg_query.PartitionElem.collation) return _impl_.collation_; } // repeated .pg_query.Node opclass = 4 [json_name = "opclass"]; inline int PartitionElem::_internal_opclass_size() const { return _impl_.opclass_.size(); } inline int PartitionElem::opclass_size() const { return _internal_opclass_size(); } inline void PartitionElem::clear_opclass() { _impl_.opclass_.Clear(); } inline ::pg_query::Node* PartitionElem::mutable_opclass(int index) { // @@protoc_insertion_point(field_mutable:pg_query.PartitionElem.opclass) return _impl_.opclass_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* PartitionElem::mutable_opclass() { // @@protoc_insertion_point(field_mutable_list:pg_query.PartitionElem.opclass) return &_impl_.opclass_; } inline const ::pg_query::Node& PartitionElem::_internal_opclass(int index) const { return _impl_.opclass_.Get(index); } inline const ::pg_query::Node& PartitionElem::opclass(int index) const { // @@protoc_insertion_point(field_get:pg_query.PartitionElem.opclass) return _internal_opclass(index); } inline ::pg_query::Node* PartitionElem::_internal_add_opclass() { return _impl_.opclass_.Add(); } inline ::pg_query::Node* PartitionElem::add_opclass() { ::pg_query::Node* _add = _internal_add_opclass(); // @@protoc_insertion_point(field_add:pg_query.PartitionElem.opclass) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& PartitionElem::opclass() const { // @@protoc_insertion_point(field_list:pg_query.PartitionElem.opclass) return _impl_.opclass_; } // int32 location = 5 [json_name = "location"]; inline void PartitionElem::clear_location() { _impl_.location_ = 0; } inline int32_t PartitionElem::_internal_location() const { return _impl_.location_; } inline int32_t PartitionElem::location() const { // @@protoc_insertion_point(field_get:pg_query.PartitionElem.location) return _internal_location(); } inline void PartitionElem::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void PartitionElem::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.PartitionElem.location) } // ------------------------------------------------------------------- // PartitionSpec // string strategy = 1 [json_name = "strategy"]; inline void PartitionSpec::clear_strategy() { _impl_.strategy_.ClearToEmpty(); } inline const std::string& PartitionSpec::strategy() const { // @@protoc_insertion_point(field_get:pg_query.PartitionSpec.strategy) return _internal_strategy(); } template inline PROTOBUF_ALWAYS_INLINE void PartitionSpec::set_strategy(ArgT0&& arg0, ArgT... args) { _impl_.strategy_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.PartitionSpec.strategy) } inline std::string* PartitionSpec::mutable_strategy() { std::string* _s = _internal_mutable_strategy(); // @@protoc_insertion_point(field_mutable:pg_query.PartitionSpec.strategy) return _s; } inline const std::string& PartitionSpec::_internal_strategy() const { return _impl_.strategy_.Get(); } inline void PartitionSpec::_internal_set_strategy(const std::string& value) { _impl_.strategy_.Set(value, GetArenaForAllocation()); } inline std::string* PartitionSpec::_internal_mutable_strategy() { return _impl_.strategy_.Mutable(GetArenaForAllocation()); } inline std::string* PartitionSpec::release_strategy() { // @@protoc_insertion_point(field_release:pg_query.PartitionSpec.strategy) return _impl_.strategy_.Release(); } inline void PartitionSpec::set_allocated_strategy(std::string* strategy) { if (strategy != nullptr) { } else { } _impl_.strategy_.SetAllocated(strategy, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.strategy_.IsDefault()) { _impl_.strategy_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:pg_query.PartitionSpec.strategy) } // repeated .pg_query.Node part_params = 2 [json_name = "partParams"]; inline int PartitionSpec::_internal_part_params_size() const { return _impl_.part_params_.size(); } inline int PartitionSpec::part_params_size() const { return _internal_part_params_size(); } inline void PartitionSpec::clear_part_params() { _impl_.part_params_.Clear(); } inline ::pg_query::Node* PartitionSpec::mutable_part_params(int index) { // @@protoc_insertion_point(field_mutable:pg_query.PartitionSpec.part_params) return _impl_.part_params_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* PartitionSpec::mutable_part_params() { // @@protoc_insertion_point(field_mutable_list:pg_query.PartitionSpec.part_params) return &_impl_.part_params_; } inline const ::pg_query::Node& PartitionSpec::_internal_part_params(int index) const { return _impl_.part_params_.Get(index); } inline const ::pg_query::Node& PartitionSpec::part_params(int index) const { // @@protoc_insertion_point(field_get:pg_query.PartitionSpec.part_params) return _internal_part_params(index); } inline ::pg_query::Node* PartitionSpec::_internal_add_part_params() { return _impl_.part_params_.Add(); } inline ::pg_query::Node* PartitionSpec::add_part_params() { ::pg_query::Node* _add = _internal_add_part_params(); // @@protoc_insertion_point(field_add:pg_query.PartitionSpec.part_params) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& PartitionSpec::part_params() const { // @@protoc_insertion_point(field_list:pg_query.PartitionSpec.part_params) return _impl_.part_params_; } // int32 location = 3 [json_name = "location"]; inline void PartitionSpec::clear_location() { _impl_.location_ = 0; } inline int32_t PartitionSpec::_internal_location() const { return _impl_.location_; } inline int32_t PartitionSpec::location() const { // @@protoc_insertion_point(field_get:pg_query.PartitionSpec.location) return _internal_location(); } inline void PartitionSpec::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void PartitionSpec::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.PartitionSpec.location) } // ------------------------------------------------------------------- // PartitionBoundSpec // string strategy = 1 [json_name = "strategy"]; inline void PartitionBoundSpec::clear_strategy() { _impl_.strategy_.ClearToEmpty(); } inline const std::string& PartitionBoundSpec::strategy() const { // @@protoc_insertion_point(field_get:pg_query.PartitionBoundSpec.strategy) return _internal_strategy(); } template inline PROTOBUF_ALWAYS_INLINE void PartitionBoundSpec::set_strategy(ArgT0&& arg0, ArgT... args) { _impl_.strategy_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.PartitionBoundSpec.strategy) } inline std::string* PartitionBoundSpec::mutable_strategy() { 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 { return _impl_.strategy_.Get(); } inline void PartitionBoundSpec::_internal_set_strategy(const std::string& value) { _impl_.strategy_.Set(value, GetArenaForAllocation()); } inline std::string* PartitionBoundSpec::_internal_mutable_strategy() { return _impl_.strategy_.Mutable(GetArenaForAllocation()); } inline std::string* PartitionBoundSpec::release_strategy() { // @@protoc_insertion_point(field_release:pg_query.PartitionBoundSpec.strategy) return _impl_.strategy_.Release(); } inline void PartitionBoundSpec::set_allocated_strategy(std::string* strategy) { if (strategy != nullptr) { } else { } _impl_.strategy_.SetAllocated(strategy, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.strategy_.IsDefault()) { _impl_.strategy_.Set("", GetArenaForAllocation()); } #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() { _impl_.is_default_ = false; } inline bool PartitionBoundSpec::_internal_is_default() const { return _impl_.is_default_; } inline bool PartitionBoundSpec::is_default() const { // @@protoc_insertion_point(field_get:pg_query.PartitionBoundSpec.is_default) return _internal_is_default(); } inline void PartitionBoundSpec::_internal_set_is_default(bool value) { _impl_.is_default_ = value; } inline void PartitionBoundSpec::set_is_default(bool value) { _internal_set_is_default(value); // @@protoc_insertion_point(field_set:pg_query.PartitionBoundSpec.is_default) } // int32 modulus = 3 [json_name = "modulus"]; inline void PartitionBoundSpec::clear_modulus() { _impl_.modulus_ = 0; } inline int32_t PartitionBoundSpec::_internal_modulus() const { return _impl_.modulus_; } inline int32_t PartitionBoundSpec::modulus() const { // @@protoc_insertion_point(field_get:pg_query.PartitionBoundSpec.modulus) return _internal_modulus(); } inline void PartitionBoundSpec::_internal_set_modulus(int32_t value) { _impl_.modulus_ = value; } inline void PartitionBoundSpec::set_modulus(int32_t value) { _internal_set_modulus(value); // @@protoc_insertion_point(field_set:pg_query.PartitionBoundSpec.modulus) } // int32 remainder = 4 [json_name = "remainder"]; inline void PartitionBoundSpec::clear_remainder() { _impl_.remainder_ = 0; } inline int32_t PartitionBoundSpec::_internal_remainder() const { return _impl_.remainder_; } inline int32_t PartitionBoundSpec::remainder() const { // @@protoc_insertion_point(field_get:pg_query.PartitionBoundSpec.remainder) return _internal_remainder(); } inline void PartitionBoundSpec::_internal_set_remainder(int32_t value) { _impl_.remainder_ = value; } inline void PartitionBoundSpec::set_remainder(int32_t value) { _internal_set_remainder(value); // @@protoc_insertion_point(field_set:pg_query.PartitionBoundSpec.remainder) } // repeated .pg_query.Node listdatums = 5 [json_name = "listdatums"]; inline int PartitionBoundSpec::_internal_listdatums_size() const { return _impl_.listdatums_.size(); } inline int PartitionBoundSpec::listdatums_size() const { return _internal_listdatums_size(); } inline void PartitionBoundSpec::clear_listdatums() { _impl_.listdatums_.Clear(); } inline ::pg_query::Node* PartitionBoundSpec::mutable_listdatums(int index) { // @@protoc_insertion_point(field_mutable:pg_query.PartitionBoundSpec.listdatums) return _impl_.listdatums_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* PartitionBoundSpec::mutable_listdatums() { // @@protoc_insertion_point(field_mutable_list:pg_query.PartitionBoundSpec.listdatums) return &_impl_.listdatums_; } inline const ::pg_query::Node& PartitionBoundSpec::_internal_listdatums(int index) const { return _impl_.listdatums_.Get(index); } inline const ::pg_query::Node& PartitionBoundSpec::listdatums(int index) const { // @@protoc_insertion_point(field_get:pg_query.PartitionBoundSpec.listdatums) return _internal_listdatums(index); } inline ::pg_query::Node* PartitionBoundSpec::_internal_add_listdatums() { return _impl_.listdatums_.Add(); } inline ::pg_query::Node* PartitionBoundSpec::add_listdatums() { ::pg_query::Node* _add = _internal_add_listdatums(); // @@protoc_insertion_point(field_add:pg_query.PartitionBoundSpec.listdatums) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& PartitionBoundSpec::listdatums() const { // @@protoc_insertion_point(field_list:pg_query.PartitionBoundSpec.listdatums) return _impl_.listdatums_; } // repeated .pg_query.Node lowerdatums = 6 [json_name = "lowerdatums"]; inline int PartitionBoundSpec::_internal_lowerdatums_size() const { return _impl_.lowerdatums_.size(); } inline int PartitionBoundSpec::lowerdatums_size() const { return _internal_lowerdatums_size(); } inline void PartitionBoundSpec::clear_lowerdatums() { _impl_.lowerdatums_.Clear(); } inline ::pg_query::Node* PartitionBoundSpec::mutable_lowerdatums(int index) { // @@protoc_insertion_point(field_mutable:pg_query.PartitionBoundSpec.lowerdatums) return _impl_.lowerdatums_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* PartitionBoundSpec::mutable_lowerdatums() { // @@protoc_insertion_point(field_mutable_list:pg_query.PartitionBoundSpec.lowerdatums) return &_impl_.lowerdatums_; } inline const ::pg_query::Node& PartitionBoundSpec::_internal_lowerdatums(int index) const { return _impl_.lowerdatums_.Get(index); } inline const ::pg_query::Node& PartitionBoundSpec::lowerdatums(int index) const { // @@protoc_insertion_point(field_get:pg_query.PartitionBoundSpec.lowerdatums) return _internal_lowerdatums(index); } inline ::pg_query::Node* PartitionBoundSpec::_internal_add_lowerdatums() { return _impl_.lowerdatums_.Add(); } inline ::pg_query::Node* PartitionBoundSpec::add_lowerdatums() { ::pg_query::Node* _add = _internal_add_lowerdatums(); // @@protoc_insertion_point(field_add:pg_query.PartitionBoundSpec.lowerdatums) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& PartitionBoundSpec::lowerdatums() const { // @@protoc_insertion_point(field_list:pg_query.PartitionBoundSpec.lowerdatums) return _impl_.lowerdatums_; } // repeated .pg_query.Node upperdatums = 7 [json_name = "upperdatums"]; inline int PartitionBoundSpec::_internal_upperdatums_size() const { return _impl_.upperdatums_.size(); } inline int PartitionBoundSpec::upperdatums_size() const { return _internal_upperdatums_size(); } inline void PartitionBoundSpec::clear_upperdatums() { _impl_.upperdatums_.Clear(); } inline ::pg_query::Node* PartitionBoundSpec::mutable_upperdatums(int index) { // @@protoc_insertion_point(field_mutable:pg_query.PartitionBoundSpec.upperdatums) return _impl_.upperdatums_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* PartitionBoundSpec::mutable_upperdatums() { // @@protoc_insertion_point(field_mutable_list:pg_query.PartitionBoundSpec.upperdatums) return &_impl_.upperdatums_; } inline const ::pg_query::Node& PartitionBoundSpec::_internal_upperdatums(int index) const { return _impl_.upperdatums_.Get(index); } inline const ::pg_query::Node& PartitionBoundSpec::upperdatums(int index) const { // @@protoc_insertion_point(field_get:pg_query.PartitionBoundSpec.upperdatums) return _internal_upperdatums(index); } inline ::pg_query::Node* PartitionBoundSpec::_internal_add_upperdatums() { return _impl_.upperdatums_.Add(); } inline ::pg_query::Node* PartitionBoundSpec::add_upperdatums() { ::pg_query::Node* _add = _internal_add_upperdatums(); // @@protoc_insertion_point(field_add:pg_query.PartitionBoundSpec.upperdatums) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& PartitionBoundSpec::upperdatums() const { // @@protoc_insertion_point(field_list:pg_query.PartitionBoundSpec.upperdatums) return _impl_.upperdatums_; } // int32 location = 8 [json_name = "location"]; inline void PartitionBoundSpec::clear_location() { _impl_.location_ = 0; } inline int32_t PartitionBoundSpec::_internal_location() const { return _impl_.location_; } inline int32_t PartitionBoundSpec::location() const { // @@protoc_insertion_point(field_get:pg_query.PartitionBoundSpec.location) return _internal_location(); } inline void PartitionBoundSpec::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void PartitionBoundSpec::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.PartitionBoundSpec.location) } // ------------------------------------------------------------------- // PartitionRangeDatum // .pg_query.PartitionRangeDatumKind kind = 1 [json_name = "kind"]; inline void PartitionRangeDatum::clear_kind() { _impl_.kind_ = 0; } inline ::pg_query::PartitionRangeDatumKind PartitionRangeDatum::_internal_kind() const { return static_cast< ::pg_query::PartitionRangeDatumKind >(_impl_.kind_); } inline ::pg_query::PartitionRangeDatumKind PartitionRangeDatum::kind() const { // @@protoc_insertion_point(field_get:pg_query.PartitionRangeDatum.kind) return _internal_kind(); } inline void PartitionRangeDatum::_internal_set_kind(::pg_query::PartitionRangeDatumKind value) { _impl_.kind_ = value; } inline void PartitionRangeDatum::set_kind(::pg_query::PartitionRangeDatumKind value) { _internal_set_kind(value); // @@protoc_insertion_point(field_set:pg_query.PartitionRangeDatum.kind) } // .pg_query.Node value = 2 [json_name = "value"]; inline bool PartitionRangeDatum::_internal_has_value() const { return this != internal_default_instance() && _impl_.value_ != nullptr; } inline bool PartitionRangeDatum::has_value() const { return _internal_has_value(); } inline void PartitionRangeDatum::clear_value() { if (GetArenaForAllocation() == nullptr && _impl_.value_ != nullptr) { delete _impl_.value_; } _impl_.value_ = nullptr; } inline const ::pg_query::Node& PartitionRangeDatum::_internal_value() const { const ::pg_query::Node* p = _impl_.value_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& PartitionRangeDatum::value() const { // @@protoc_insertion_point(field_get:pg_query.PartitionRangeDatum.value) return _internal_value(); } inline void PartitionRangeDatum::unsafe_arena_set_allocated_value( ::pg_query::Node* value) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.value_); } _impl_.value_ = value; if (value) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.PartitionRangeDatum.value) } inline ::pg_query::Node* PartitionRangeDatum::release_value() { ::pg_query::Node* temp = _impl_.value_; _impl_.value_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* PartitionRangeDatum::unsafe_arena_release_value() { // @@protoc_insertion_point(field_release:pg_query.PartitionRangeDatum.value) ::pg_query::Node* temp = _impl_.value_; _impl_.value_ = nullptr; return temp; } inline ::pg_query::Node* PartitionRangeDatum::_internal_mutable_value() { if (_impl_.value_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.value_ = p; } return _impl_.value_; } inline ::pg_query::Node* PartitionRangeDatum::mutable_value() { ::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) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.value_; } if (value) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(value); if (message_arena != submessage_arena) { value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, value, submessage_arena); } } else { } _impl_.value_ = value; // @@protoc_insertion_point(field_set_allocated:pg_query.PartitionRangeDatum.value) } // int32 location = 3 [json_name = "location"]; inline void PartitionRangeDatum::clear_location() { _impl_.location_ = 0; } inline int32_t PartitionRangeDatum::_internal_location() const { return _impl_.location_; } inline int32_t PartitionRangeDatum::location() const { // @@protoc_insertion_point(field_get:pg_query.PartitionRangeDatum.location) return _internal_location(); } inline void PartitionRangeDatum::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void PartitionRangeDatum::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.PartitionRangeDatum.location) } // ------------------------------------------------------------------- // PartitionCmd // .pg_query.RangeVar name = 1 [json_name = "name"]; inline bool PartitionCmd::_internal_has_name() const { return this != internal_default_instance() && _impl_.name_ != nullptr; } inline bool PartitionCmd::has_name() const { return _internal_has_name(); } inline void PartitionCmd::clear_name() { if (GetArenaForAllocation() == nullptr && _impl_.name_ != nullptr) { delete _impl_.name_; } _impl_.name_ = nullptr; } inline const ::pg_query::RangeVar& PartitionCmd::_internal_name() const { const ::pg_query::RangeVar* p = _impl_.name_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& PartitionCmd::name() const { // @@protoc_insertion_point(field_get:pg_query.PartitionCmd.name) return _internal_name(); } inline void PartitionCmd::unsafe_arena_set_allocated_name( ::pg_query::RangeVar* name) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.name_); } _impl_.name_ = name; if (name) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.PartitionCmd.name) } inline ::pg_query::RangeVar* PartitionCmd::release_name() { ::pg_query::RangeVar* temp = _impl_.name_; _impl_.name_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* PartitionCmd::unsafe_arena_release_name() { // @@protoc_insertion_point(field_release:pg_query.PartitionCmd.name) ::pg_query::RangeVar* temp = _impl_.name_; _impl_.name_ = nullptr; return temp; } inline ::pg_query::RangeVar* PartitionCmd::_internal_mutable_name() { if (_impl_.name_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.name_ = p; } return _impl_.name_; } inline ::pg_query::RangeVar* PartitionCmd::mutable_name() { ::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* name) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.name_; } if (name) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(name); if (message_arena != submessage_arena) { name = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, name, submessage_arena); } } else { } _impl_.name_ = name; // @@protoc_insertion_point(field_set_allocated:pg_query.PartitionCmd.name) } // .pg_query.PartitionBoundSpec bound = 2 [json_name = "bound"]; inline bool PartitionCmd::_internal_has_bound() const { return this != internal_default_instance() && _impl_.bound_ != nullptr; } inline bool PartitionCmd::has_bound() const { return _internal_has_bound(); } inline void PartitionCmd::clear_bound() { if (GetArenaForAllocation() == nullptr && _impl_.bound_ != nullptr) { delete _impl_.bound_; } _impl_.bound_ = nullptr; } inline const ::pg_query::PartitionBoundSpec& PartitionCmd::_internal_bound() const { const ::pg_query::PartitionBoundSpec* p = _impl_.bound_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_PartitionBoundSpec_default_instance_); } inline const ::pg_query::PartitionBoundSpec& PartitionCmd::bound() const { // @@protoc_insertion_point(field_get:pg_query.PartitionCmd.bound) return _internal_bound(); } inline void PartitionCmd::unsafe_arena_set_allocated_bound( ::pg_query::PartitionBoundSpec* bound) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.bound_); } _impl_.bound_ = bound; if (bound) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.PartitionCmd.bound) } inline ::pg_query::PartitionBoundSpec* PartitionCmd::release_bound() { ::pg_query::PartitionBoundSpec* temp = _impl_.bound_; _impl_.bound_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::PartitionBoundSpec* PartitionCmd::unsafe_arena_release_bound() { // @@protoc_insertion_point(field_release:pg_query.PartitionCmd.bound) ::pg_query::PartitionBoundSpec* temp = _impl_.bound_; _impl_.bound_ = nullptr; return temp; } inline ::pg_query::PartitionBoundSpec* PartitionCmd::_internal_mutable_bound() { if (_impl_.bound_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::PartitionBoundSpec>(GetArenaForAllocation()); _impl_.bound_ = p; } return _impl_.bound_; } inline ::pg_query::PartitionBoundSpec* PartitionCmd::mutable_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* bound) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.bound_; } if (bound) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(bound); if (message_arena != submessage_arena) { bound = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, bound, submessage_arena); } } else { } _impl_.bound_ = bound; // @@protoc_insertion_point(field_set_allocated:pg_query.PartitionCmd.bound) } // bool concurrent = 3 [json_name = "concurrent"]; inline void PartitionCmd::clear_concurrent() { _impl_.concurrent_ = false; } inline bool PartitionCmd::_internal_concurrent() const { return _impl_.concurrent_; } inline bool PartitionCmd::concurrent() const { // @@protoc_insertion_point(field_get:pg_query.PartitionCmd.concurrent) return _internal_concurrent(); } inline void PartitionCmd::_internal_set_concurrent(bool value) { _impl_.concurrent_ = value; } inline void PartitionCmd::set_concurrent(bool value) { _internal_set_concurrent(value); // @@protoc_insertion_point(field_set:pg_query.PartitionCmd.concurrent) } // ------------------------------------------------------------------- // VacuumRelation // .pg_query.RangeVar relation = 1 [json_name = "relation"]; inline bool VacuumRelation::_internal_has_relation() const { return this != internal_default_instance() && _impl_.relation_ != nullptr; } inline bool VacuumRelation::has_relation() const { return _internal_has_relation(); } inline void VacuumRelation::clear_relation() { if (GetArenaForAllocation() == nullptr && _impl_.relation_ != nullptr) { delete _impl_.relation_; } _impl_.relation_ = nullptr; } inline const ::pg_query::RangeVar& VacuumRelation::_internal_relation() const { const ::pg_query::RangeVar* p = _impl_.relation_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& VacuumRelation::relation() const { // @@protoc_insertion_point(field_get:pg_query.VacuumRelation.relation) return _internal_relation(); } inline void VacuumRelation::unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.relation_); } _impl_.relation_ = relation; if (relation) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.VacuumRelation.relation) } inline ::pg_query::RangeVar* VacuumRelation::release_relation() { ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* VacuumRelation::unsafe_arena_release_relation() { // @@protoc_insertion_point(field_release:pg_query.VacuumRelation.relation) ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; return temp; } inline ::pg_query::RangeVar* VacuumRelation::_internal_mutable_relation() { if (_impl_.relation_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.relation_ = p; } return _impl_.relation_; } inline ::pg_query::RangeVar* VacuumRelation::mutable_relation() { ::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* relation) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.relation_; } if (relation) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(relation); if (message_arena != submessage_arena) { relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, relation, submessage_arena); } } else { } _impl_.relation_ = relation; // @@protoc_insertion_point(field_set_allocated:pg_query.VacuumRelation.relation) } // uint32 oid = 2 [json_name = "oid"]; inline void VacuumRelation::clear_oid() { _impl_.oid_ = 0u; } inline uint32_t VacuumRelation::_internal_oid() const { return _impl_.oid_; } inline uint32_t VacuumRelation::oid() const { // @@protoc_insertion_point(field_get:pg_query.VacuumRelation.oid) return _internal_oid(); } inline void VacuumRelation::_internal_set_oid(uint32_t value) { _impl_.oid_ = value; } inline void VacuumRelation::set_oid(uint32_t value) { _internal_set_oid(value); // @@protoc_insertion_point(field_set:pg_query.VacuumRelation.oid) } // repeated .pg_query.Node va_cols = 3 [json_name = "va_cols"]; inline int VacuumRelation::_internal_va_cols_size() const { return _impl_.va_cols_.size(); } inline int VacuumRelation::va_cols_size() const { return _internal_va_cols_size(); } inline void VacuumRelation::clear_va_cols() { _impl_.va_cols_.Clear(); } inline ::pg_query::Node* VacuumRelation::mutable_va_cols(int index) { // @@protoc_insertion_point(field_mutable:pg_query.VacuumRelation.va_cols) return _impl_.va_cols_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* VacuumRelation::mutable_va_cols() { // @@protoc_insertion_point(field_mutable_list:pg_query.VacuumRelation.va_cols) return &_impl_.va_cols_; } inline const ::pg_query::Node& VacuumRelation::_internal_va_cols(int index) const { return _impl_.va_cols_.Get(index); } inline const ::pg_query::Node& VacuumRelation::va_cols(int index) const { // @@protoc_insertion_point(field_get:pg_query.VacuumRelation.va_cols) return _internal_va_cols(index); } inline ::pg_query::Node* VacuumRelation::_internal_add_va_cols() { return _impl_.va_cols_.Add(); } inline ::pg_query::Node* VacuumRelation::add_va_cols() { ::pg_query::Node* _add = _internal_add_va_cols(); // @@protoc_insertion_point(field_add:pg_query.VacuumRelation.va_cols) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& VacuumRelation::va_cols() const { // @@protoc_insertion_point(field_list:pg_query.VacuumRelation.va_cols) return _impl_.va_cols_; } // ------------------------------------------------------------------- // PublicationObjSpec // .pg_query.PublicationObjSpecType pubobjtype = 1 [json_name = "pubobjtype"]; inline void PublicationObjSpec::clear_pubobjtype() { _impl_.pubobjtype_ = 0; } inline ::pg_query::PublicationObjSpecType PublicationObjSpec::_internal_pubobjtype() const { return static_cast< ::pg_query::PublicationObjSpecType >(_impl_.pubobjtype_); } inline ::pg_query::PublicationObjSpecType PublicationObjSpec::pubobjtype() const { // @@protoc_insertion_point(field_get:pg_query.PublicationObjSpec.pubobjtype) return _internal_pubobjtype(); } inline void PublicationObjSpec::_internal_set_pubobjtype(::pg_query::PublicationObjSpecType value) { _impl_.pubobjtype_ = value; } inline void PublicationObjSpec::set_pubobjtype(::pg_query::PublicationObjSpecType value) { _internal_set_pubobjtype(value); // @@protoc_insertion_point(field_set:pg_query.PublicationObjSpec.pubobjtype) } // string name = 2 [json_name = "name"]; inline void PublicationObjSpec::clear_name() { _impl_.name_.ClearToEmpty(); } inline const std::string& PublicationObjSpec::name() const { // @@protoc_insertion_point(field_get:pg_query.PublicationObjSpec.name) return _internal_name(); } template inline PROTOBUF_ALWAYS_INLINE void PublicationObjSpec::set_name(ArgT0&& arg0, ArgT... args) { _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.PublicationObjSpec.name) } inline std::string* PublicationObjSpec::mutable_name() { 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 { return _impl_.name_.Get(); } inline void PublicationObjSpec::_internal_set_name(const std::string& value) { _impl_.name_.Set(value, GetArenaForAllocation()); } inline std::string* PublicationObjSpec::_internal_mutable_name() { return _impl_.name_.Mutable(GetArenaForAllocation()); } inline std::string* PublicationObjSpec::release_name() { // @@protoc_insertion_point(field_release:pg_query.PublicationObjSpec.name) return _impl_.name_.Release(); } inline void PublicationObjSpec::set_allocated_name(std::string* name) { if (name != nullptr) { } else { } _impl_.name_.SetAllocated(name, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.name_.IsDefault()) { _impl_.name_.Set("", GetArenaForAllocation()); } #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::_internal_has_pubtable() const { return this != internal_default_instance() && _impl_.pubtable_ != nullptr; } inline bool PublicationObjSpec::has_pubtable() const { return _internal_has_pubtable(); } inline void PublicationObjSpec::clear_pubtable() { if (GetArenaForAllocation() == nullptr && _impl_.pubtable_ != nullptr) { delete _impl_.pubtable_; } _impl_.pubtable_ = nullptr; } inline const ::pg_query::PublicationTable& PublicationObjSpec::_internal_pubtable() const { const ::pg_query::PublicationTable* p = _impl_.pubtable_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_PublicationTable_default_instance_); } inline const ::pg_query::PublicationTable& PublicationObjSpec::pubtable() const { // @@protoc_insertion_point(field_get:pg_query.PublicationObjSpec.pubtable) return _internal_pubtable(); } inline void PublicationObjSpec::unsafe_arena_set_allocated_pubtable( ::pg_query::PublicationTable* pubtable) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pubtable_); } _impl_.pubtable_ = pubtable; if (pubtable) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.PublicationObjSpec.pubtable) } inline ::pg_query::PublicationTable* PublicationObjSpec::release_pubtable() { ::pg_query::PublicationTable* temp = _impl_.pubtable_; _impl_.pubtable_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::PublicationTable* PublicationObjSpec::unsafe_arena_release_pubtable() { // @@protoc_insertion_point(field_release:pg_query.PublicationObjSpec.pubtable) ::pg_query::PublicationTable* temp = _impl_.pubtable_; _impl_.pubtable_ = nullptr; return temp; } inline ::pg_query::PublicationTable* PublicationObjSpec::_internal_mutable_pubtable() { if (_impl_.pubtable_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::PublicationTable>(GetArenaForAllocation()); _impl_.pubtable_ = p; } return _impl_.pubtable_; } inline ::pg_query::PublicationTable* PublicationObjSpec::mutable_pubtable() { ::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* pubtable) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.pubtable_; } if (pubtable) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pubtable); if (message_arena != submessage_arena) { pubtable = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, pubtable, submessage_arena); } } else { } _impl_.pubtable_ = pubtable; // @@protoc_insertion_point(field_set_allocated:pg_query.PublicationObjSpec.pubtable) } // int32 location = 4 [json_name = "location"]; inline void PublicationObjSpec::clear_location() { _impl_.location_ = 0; } inline int32_t PublicationObjSpec::_internal_location() const { return _impl_.location_; } inline int32_t PublicationObjSpec::location() const { // @@protoc_insertion_point(field_get:pg_query.PublicationObjSpec.location) return _internal_location(); } inline void PublicationObjSpec::_internal_set_location(int32_t value) { _impl_.location_ = value; } inline void PublicationObjSpec::set_location(int32_t value) { _internal_set_location(value); // @@protoc_insertion_point(field_set:pg_query.PublicationObjSpec.location) } // ------------------------------------------------------------------- // PublicationTable // .pg_query.RangeVar relation = 1 [json_name = "relation"]; inline bool PublicationTable::_internal_has_relation() const { return this != internal_default_instance() && _impl_.relation_ != nullptr; } inline bool PublicationTable::has_relation() const { return _internal_has_relation(); } inline void PublicationTable::clear_relation() { if (GetArenaForAllocation() == nullptr && _impl_.relation_ != nullptr) { delete _impl_.relation_; } _impl_.relation_ = nullptr; } inline const ::pg_query::RangeVar& PublicationTable::_internal_relation() const { const ::pg_query::RangeVar* p = _impl_.relation_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_RangeVar_default_instance_); } inline const ::pg_query::RangeVar& PublicationTable::relation() const { // @@protoc_insertion_point(field_get:pg_query.PublicationTable.relation) return _internal_relation(); } inline void PublicationTable::unsafe_arena_set_allocated_relation( ::pg_query::RangeVar* relation) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.relation_); } _impl_.relation_ = relation; if (relation) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.PublicationTable.relation) } inline ::pg_query::RangeVar* PublicationTable::release_relation() { ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::RangeVar* PublicationTable::unsafe_arena_release_relation() { // @@protoc_insertion_point(field_release:pg_query.PublicationTable.relation) ::pg_query::RangeVar* temp = _impl_.relation_; _impl_.relation_ = nullptr; return temp; } inline ::pg_query::RangeVar* PublicationTable::_internal_mutable_relation() { if (_impl_.relation_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::RangeVar>(GetArenaForAllocation()); _impl_.relation_ = p; } return _impl_.relation_; } inline ::pg_query::RangeVar* PublicationTable::mutable_relation() { ::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* relation) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.relation_; } if (relation) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(relation); if (message_arena != submessage_arena) { relation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, relation, submessage_arena); } } else { } _impl_.relation_ = relation; // @@protoc_insertion_point(field_set_allocated:pg_query.PublicationTable.relation) } // .pg_query.Node where_clause = 2 [json_name = "whereClause"]; inline bool PublicationTable::_internal_has_where_clause() const { return this != internal_default_instance() && _impl_.where_clause_ != nullptr; } inline bool PublicationTable::has_where_clause() const { return _internal_has_where_clause(); } inline void PublicationTable::clear_where_clause() { if (GetArenaForAllocation() == nullptr && _impl_.where_clause_ != nullptr) { delete _impl_.where_clause_; } _impl_.where_clause_ = nullptr; } inline const ::pg_query::Node& PublicationTable::_internal_where_clause() const { const ::pg_query::Node* p = _impl_.where_clause_; return p != nullptr ? *p : reinterpret_cast( ::pg_query::_Node_default_instance_); } inline const ::pg_query::Node& PublicationTable::where_clause() const { // @@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* where_clause) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.where_clause_); } _impl_.where_clause_ = where_clause; if (where_clause) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pg_query.PublicationTable.where_clause) } inline ::pg_query::Node* PublicationTable::release_where_clause() { ::pg_query::Node* temp = _impl_.where_clause_; _impl_.where_clause_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::pg_query::Node* PublicationTable::unsafe_arena_release_where_clause() { // @@protoc_insertion_point(field_release:pg_query.PublicationTable.where_clause) ::pg_query::Node* temp = _impl_.where_clause_; _impl_.where_clause_ = nullptr; return temp; } inline ::pg_query::Node* PublicationTable::_internal_mutable_where_clause() { if (_impl_.where_clause_ == nullptr) { auto* p = CreateMaybeMessage<::pg_query::Node>(GetArenaForAllocation()); _impl_.where_clause_ = p; } return _impl_.where_clause_; } inline ::pg_query::Node* PublicationTable::mutable_where_clause() { ::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* where_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.where_clause_; } if (where_clause) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(where_clause); if (message_arena != submessage_arena) { where_clause = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, where_clause, submessage_arena); } } else { } _impl_.where_clause_ = where_clause; // @@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 _impl_.columns_.size(); } inline int PublicationTable::columns_size() const { return _internal_columns_size(); } inline void PublicationTable::clear_columns() { _impl_.columns_.Clear(); } inline ::pg_query::Node* PublicationTable::mutable_columns(int index) { // @@protoc_insertion_point(field_mutable:pg_query.PublicationTable.columns) return _impl_.columns_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >* PublicationTable::mutable_columns() { // @@protoc_insertion_point(field_mutable_list:pg_query.PublicationTable.columns) return &_impl_.columns_; } inline const ::pg_query::Node& PublicationTable::_internal_columns(int index) const { return _impl_.columns_.Get(index); } inline const ::pg_query::Node& PublicationTable::columns(int index) const { // @@protoc_insertion_point(field_get:pg_query.PublicationTable.columns) return _internal_columns(index); } inline ::pg_query::Node* PublicationTable::_internal_add_columns() { return _impl_.columns_.Add(); } inline ::pg_query::Node* PublicationTable::add_columns() { ::pg_query::Node* _add = _internal_add_columns(); // @@protoc_insertion_point(field_add:pg_query.PublicationTable.columns) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pg_query::Node >& PublicationTable::columns() const { // @@protoc_insertion_point(field_list:pg_query.PublicationTable.columns) return _impl_.columns_; } // ------------------------------------------------------------------- // InlineCodeBlock // string source_text = 1 [json_name = "source_text"]; inline void InlineCodeBlock::clear_source_text() { _impl_.source_text_.ClearToEmpty(); } inline const std::string& InlineCodeBlock::source_text() const { // @@protoc_insertion_point(field_get:pg_query.InlineCodeBlock.source_text) return _internal_source_text(); } template inline PROTOBUF_ALWAYS_INLINE void InlineCodeBlock::set_source_text(ArgT0&& arg0, ArgT... args) { _impl_.source_text_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:pg_query.InlineCodeBlock.source_text) } inline std::string* InlineCodeBlock::mutable_source_text() { 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 { return _impl_.source_text_.Get(); } inline void InlineCodeBlock::_internal_set_source_text(const std::string& value) { _impl_.source_text_.Set(value, GetArenaForAllocation()); } inline std::string* InlineCodeBlock::_internal_mutable_source_text() { return _impl_.source_text_.Mutable(GetArenaForAllocation()); } inline std::string* InlineCodeBlock::release_source_text() { // @@protoc_insertion_point(field_release:pg_query.InlineCodeBlock.source_text) return _impl_.source_text_.Release(); } inline void InlineCodeBlock::set_allocated_source_text(std::string* source_text) { if (source_text != nullptr) { } else { } _impl_.source_text_.SetAllocated(source_text, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.source_text_.IsDefault()) { _impl_.source_text_.Set("", GetArenaForAllocation()); } #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() { _impl_.lang_oid_ = 0u; } inline uint32_t InlineCodeBlock::_internal_lang_oid() const { return _impl_.lang_oid_; } inline uint32_t InlineCodeBlock::lang_oid() const { // @@protoc_insertion_point(field_get:pg_query.InlineCodeBlock.lang_oid) return _internal_lang_oid(); } inline void InlineCodeBlock::_internal_set_lang_oid(uint32_t value) { _impl_.lang_oid_ = value; } inline void InlineCodeBlock::set_lang_oid(uint32_t value) { _internal_set_lang_oid(value); // @@protoc_insertion_point(field_set:pg_query.InlineCodeBlock.lang_oid) } // bool lang_is_trusted = 3 [json_name = "langIsTrusted"]; inline void InlineCodeBlock::clear_lang_is_trusted() { _impl_.lang_is_trusted_ = false; } inline bool InlineCodeBlock::_internal_lang_is_trusted() const { return _impl_.lang_is_trusted_; } inline bool InlineCodeBlock::lang_is_trusted() const { // @@protoc_insertion_point(field_get:pg_query.InlineCodeBlock.lang_is_trusted) return _internal_lang_is_trusted(); } inline void InlineCodeBlock::_internal_set_lang_is_trusted(bool value) { _impl_.lang_is_trusted_ = value; } inline void InlineCodeBlock::set_lang_is_trusted(bool value) { _internal_set_lang_is_trusted(value); // @@protoc_insertion_point(field_set:pg_query.InlineCodeBlock.lang_is_trusted) } // bool atomic = 4 [json_name = "atomic"]; inline void InlineCodeBlock::clear_atomic() { _impl_.atomic_ = false; } inline bool InlineCodeBlock::_internal_atomic() const { return _impl_.atomic_; } inline bool InlineCodeBlock::atomic() const { // @@protoc_insertion_point(field_get:pg_query.InlineCodeBlock.atomic) return _internal_atomic(); } inline void InlineCodeBlock::_internal_set_atomic(bool value) { _impl_.atomic_ = value; } inline void InlineCodeBlock::set_atomic(bool value) { _internal_set_atomic(value); // @@protoc_insertion_point(field_set:pg_query.InlineCodeBlock.atomic) } // ------------------------------------------------------------------- // CallContext // bool atomic = 1 [json_name = "atomic"]; inline void CallContext::clear_atomic() { _impl_.atomic_ = false; } inline bool CallContext::_internal_atomic() const { return _impl_.atomic_; } inline bool CallContext::atomic() const { // @@protoc_insertion_point(field_get:pg_query.CallContext.atomic) return _internal_atomic(); } inline void CallContext::_internal_set_atomic(bool value) { _impl_.atomic_ = value; } inline void CallContext::set_atomic(bool value) { _internal_set_atomic(value); // @@protoc_insertion_point(field_set:pg_query.CallContext.atomic) } // ------------------------------------------------------------------- // ScanToken // int32 start = 1; inline void ScanToken::clear_start() { _impl_.start_ = 0; } inline int32_t ScanToken::_internal_start() const { return _impl_.start_; } inline int32_t ScanToken::start() const { // @@protoc_insertion_point(field_get:pg_query.ScanToken.start) return _internal_start(); } inline void ScanToken::_internal_set_start(int32_t value) { _impl_.start_ = value; } inline void ScanToken::set_start(int32_t value) { _internal_set_start(value); // @@protoc_insertion_point(field_set:pg_query.ScanToken.start) } // int32 end = 2; inline void ScanToken::clear_end() { _impl_.end_ = 0; } inline int32_t ScanToken::_internal_end() const { return _impl_.end_; } inline int32_t ScanToken::end() const { // @@protoc_insertion_point(field_get:pg_query.ScanToken.end) return _internal_end(); } inline void ScanToken::_internal_set_end(int32_t value) { _impl_.end_ = value; } inline void ScanToken::set_end(int32_t value) { _internal_set_end(value); // @@protoc_insertion_point(field_set:pg_query.ScanToken.end) } // .pg_query.Token token = 4; inline void ScanToken::clear_token() { _impl_.token_ = 0; } inline ::pg_query::Token ScanToken::_internal_token() const { return static_cast< ::pg_query::Token >(_impl_.token_); } inline ::pg_query::Token ScanToken::token() const { // @@protoc_insertion_point(field_get:pg_query.ScanToken.token) return _internal_token(); } inline void ScanToken::_internal_set_token(::pg_query::Token value) { _impl_.token_ = value; } inline void ScanToken::set_token(::pg_query::Token value) { _internal_set_token(value); // @@protoc_insertion_point(field_set:pg_query.ScanToken.token) } // .pg_query.KeywordKind keyword_kind = 5; inline void ScanToken::clear_keyword_kind() { _impl_.keyword_kind_ = 0; } inline ::pg_query::KeywordKind ScanToken::_internal_keyword_kind() const { return static_cast< ::pg_query::KeywordKind >(_impl_.keyword_kind_); } inline ::pg_query::KeywordKind ScanToken::keyword_kind() const { // @@protoc_insertion_point(field_get:pg_query.ScanToken.keyword_kind) return _internal_keyword_kind(); } inline void ScanToken::_internal_set_keyword_kind(::pg_query::KeywordKind value) { _impl_.keyword_kind_ = value; } inline void ScanToken::set_keyword_kind(::pg_query::KeywordKind value) { _internal_set_keyword_kind(value); // @@protoc_insertion_point(field_set:pg_query.ScanToken.keyword_kind) } #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // @@protoc_insertion_point(namespace_scope) } // namespace pg_query PROTOBUF_NAMESPACE_OPEN template <> struct is_proto_enum< ::pg_query::OverridingKind> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::OverridingKind>() { return ::pg_query::OverridingKind_descriptor(); } template <> struct is_proto_enum< ::pg_query::QuerySource> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::QuerySource>() { return ::pg_query::QuerySource_descriptor(); } template <> struct is_proto_enum< ::pg_query::SortByDir> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::SortByDir>() { return ::pg_query::SortByDir_descriptor(); } template <> struct is_proto_enum< ::pg_query::SortByNulls> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::SortByNulls>() { return ::pg_query::SortByNulls_descriptor(); } template <> struct is_proto_enum< ::pg_query::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::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::NullTestType> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::NullTestType>() { return ::pg_query::NullTestType_descriptor(); } template <> struct is_proto_enum< ::pg_query::BoolTestType> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::BoolTestType>() { return ::pg_query::BoolTestType_descriptor(); } template <> struct is_proto_enum< ::pg_query::CmdType> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::CmdType>() { return ::pg_query::CmdType_descriptor(); } template <> struct is_proto_enum< ::pg_query::JoinType> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::JoinType>() { return ::pg_query::JoinType_descriptor(); } template <> struct is_proto_enum< ::pg_query::AggStrategy> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::AggStrategy>() { return ::pg_query::AggStrategy_descriptor(); } template <> struct is_proto_enum< ::pg_query::AggSplit> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::AggSplit>() { return ::pg_query::AggSplit_descriptor(); } template <> struct is_proto_enum< ::pg_query::SetOpCmd> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::SetOpCmd>() { return ::pg_query::SetOpCmd_descriptor(); } template <> struct is_proto_enum< ::pg_query::SetOpStrategy> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::SetOpStrategy>() { return ::pg_query::SetOpStrategy_descriptor(); } template <> struct is_proto_enum< ::pg_query::OnConflictAction> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::OnConflictAction>() { return ::pg_query::OnConflictAction_descriptor(); } template <> struct is_proto_enum< ::pg_query::LimitOption> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::LimitOption>() { return ::pg_query::LimitOption_descriptor(); } template <> struct is_proto_enum< ::pg_query::LockClauseStrength> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::LockClauseStrength>() { return ::pg_query::LockClauseStrength_descriptor(); } template <> struct is_proto_enum< ::pg_query::LockWaitPolicy> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::LockWaitPolicy>() { return ::pg_query::LockWaitPolicy_descriptor(); } template <> struct is_proto_enum< ::pg_query::LockTupleMode> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::LockTupleMode>() { return ::pg_query::LockTupleMode_descriptor(); } template <> struct is_proto_enum< ::pg_query::KeywordKind> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::KeywordKind>() { return ::pg_query::KeywordKind_descriptor(); } template <> struct is_proto_enum< ::pg_query::Token> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::pg_query::Token>() { return ::pg_query::Token_descriptor(); } PROTOBUF_NAMESPACE_CLOSE // @@protoc_insertion_point(global_scope) #include #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protobuf_2fpg_5fquery_2eproto