pg_query 18.1.0

// This file is autogenerated by ./scripts/generate_protobuf_and_funcs.rb

static Alias * _readAlias(const OUT_TYPE(Alias, Alias) msg);
static RangeVar * _readRangeVar(const OUT_TYPE(RangeVar, RangeVar) msg);
static TableFunc * _readTableFunc(const OUT_TYPE(TableFunc, TableFunc) msg);
static IntoClause * _readIntoClause(const OUT_TYPE(IntoClause, IntoClause) msg);
static Var * _readVar(const OUT_TYPE(Var, Var) msg);
static Param * _readParam(const OUT_TYPE(Param, Param) msg);
static Aggref * _readAggref(const OUT_TYPE(Aggref, Aggref) msg);
static GroupingFunc * _readGroupingFunc(const OUT_TYPE(GroupingFunc, GroupingFunc) msg);
static WindowFunc * _readWindowFunc(const OUT_TYPE(WindowFunc, WindowFunc) msg);
static WindowFuncRunCondition * _readWindowFuncRunCondition(const OUT_TYPE(WindowFuncRunCondition, WindowFuncRunCondition) msg);
static MergeSupportFunc * _readMergeSupportFunc(const OUT_TYPE(MergeSupportFunc, MergeSupportFunc) msg);
static SubscriptingRef * _readSubscriptingRef(const OUT_TYPE(SubscriptingRef, SubscriptingRef) msg);
static FuncExpr * _readFuncExpr(const OUT_TYPE(FuncExpr, FuncExpr) msg);
static NamedArgExpr * _readNamedArgExpr(const OUT_TYPE(NamedArgExpr, NamedArgExpr) msg);
static OpExpr * _readOpExpr(const OUT_TYPE(OpExpr, OpExpr) msg);
static DistinctExpr * _readDistinctExpr(const OUT_TYPE(DistinctExpr, DistinctExpr) msg);
static NullIfExpr * _readNullIfExpr(const OUT_TYPE(NullIfExpr, NullIfExpr) msg);
static ScalarArrayOpExpr * _readScalarArrayOpExpr(const OUT_TYPE(ScalarArrayOpExpr, ScalarArrayOpExpr) msg);
static BoolExpr * _readBoolExpr(const OUT_TYPE(BoolExpr, BoolExpr) msg);
static SubLink * _readSubLink(const OUT_TYPE(SubLink, SubLink) msg);
static SubPlan * _readSubPlan(const OUT_TYPE(SubPlan, SubPlan) msg);
static AlternativeSubPlan * _readAlternativeSubPlan(const OUT_TYPE(AlternativeSubPlan, AlternativeSubPlan) msg);
static FieldSelect * _readFieldSelect(const OUT_TYPE(FieldSelect, FieldSelect) msg);
static FieldStore * _readFieldStore(const OUT_TYPE(FieldStore, FieldStore) msg);
static RelabelType * _readRelabelType(const OUT_TYPE(RelabelType, RelabelType) msg);
static CoerceViaIO * _readCoerceViaIO(const OUT_TYPE(CoerceViaIO, CoerceViaIO) msg);
static ArrayCoerceExpr * _readArrayCoerceExpr(const OUT_TYPE(ArrayCoerceExpr, ArrayCoerceExpr) msg);
static ConvertRowtypeExpr * _readConvertRowtypeExpr(const OUT_TYPE(ConvertRowtypeExpr, ConvertRowtypeExpr) msg);
static CollateExpr * _readCollateExpr(const OUT_TYPE(CollateExpr, CollateExpr) msg);
static CaseExpr * _readCaseExpr(const OUT_TYPE(CaseExpr, CaseExpr) msg);
static CaseWhen * _readCaseWhen(const OUT_TYPE(CaseWhen, CaseWhen) msg);
static CaseTestExpr * _readCaseTestExpr(const OUT_TYPE(CaseTestExpr, CaseTestExpr) msg);
static ArrayExpr * _readArrayExpr(const OUT_TYPE(ArrayExpr, ArrayExpr) msg);
static RowExpr * _readRowExpr(const OUT_TYPE(RowExpr, RowExpr) msg);
static RowCompareExpr * _readRowCompareExpr(const OUT_TYPE(RowCompareExpr, RowCompareExpr) msg);
static CoalesceExpr * _readCoalesceExpr(const OUT_TYPE(CoalesceExpr, CoalesceExpr) msg);
static MinMaxExpr * _readMinMaxExpr(const OUT_TYPE(MinMaxExpr, MinMaxExpr) msg);
static SQLValueFunction * _readSQLValueFunction(const OUT_TYPE(SQLValueFunction, SQLValueFunction) msg);
static XmlExpr * _readXmlExpr(const OUT_TYPE(XmlExpr, XmlExpr) msg);
static JsonFormat * _readJsonFormat(const OUT_TYPE(JsonFormat, JsonFormat) msg);
static JsonReturning * _readJsonReturning(const OUT_TYPE(JsonReturning, JsonReturning) msg);
static JsonValueExpr * _readJsonValueExpr(const OUT_TYPE(JsonValueExpr, JsonValueExpr) msg);
static JsonConstructorExpr * _readJsonConstructorExpr(const OUT_TYPE(JsonConstructorExpr, JsonConstructorExpr) msg);
static JsonIsPredicate * _readJsonIsPredicate(const OUT_TYPE(JsonIsPredicate, JsonIsPredicate) msg);
static JsonBehavior * _readJsonBehavior(const OUT_TYPE(JsonBehavior, JsonBehavior) msg);
static JsonExpr * _readJsonExpr(const OUT_TYPE(JsonExpr, JsonExpr) msg);
static JsonTablePath * _readJsonTablePath(const OUT_TYPE(JsonTablePath, JsonTablePath) msg);
static JsonTablePathScan * _readJsonTablePathScan(const OUT_TYPE(JsonTablePathScan, JsonTablePathScan) msg);
static JsonTableSiblingJoin * _readJsonTableSiblingJoin(const OUT_TYPE(JsonTableSiblingJoin, JsonTableSiblingJoin) msg);
static NullTest * _readNullTest(const OUT_TYPE(NullTest, NullTest) msg);
static BooleanTest * _readBooleanTest(const OUT_TYPE(BooleanTest, BooleanTest) msg);
static MergeAction * _readMergeAction(const OUT_TYPE(MergeAction, MergeAction) msg);
static CoerceToDomain * _readCoerceToDomain(const OUT_TYPE(CoerceToDomain, CoerceToDomain) msg);
static CoerceToDomainValue * _readCoerceToDomainValue(const OUT_TYPE(CoerceToDomainValue, CoerceToDomainValue) msg);
static SetToDefault * _readSetToDefault(const OUT_TYPE(SetToDefault, SetToDefault) msg);
static CurrentOfExpr * _readCurrentOfExpr(const OUT_TYPE(CurrentOfExpr, CurrentOfExpr) msg);
static NextValueExpr * _readNextValueExpr(const OUT_TYPE(NextValueExpr, NextValueExpr) msg);
static InferenceElem * _readInferenceElem(const OUT_TYPE(InferenceElem, InferenceElem) msg);
static ReturningExpr * _readReturningExpr(const OUT_TYPE(ReturningExpr, ReturningExpr) msg);
static TargetEntry * _readTargetEntry(const OUT_TYPE(TargetEntry, TargetEntry) msg);
static RangeTblRef * _readRangeTblRef(const OUT_TYPE(RangeTblRef, RangeTblRef) msg);
static JoinExpr * _readJoinExpr(const OUT_TYPE(JoinExpr, JoinExpr) msg);
static FromExpr * _readFromExpr(const OUT_TYPE(FromExpr, FromExpr) msg);
static OnConflictExpr * _readOnConflictExpr(const OUT_TYPE(OnConflictExpr, OnConflictExpr) msg);
static Query * _readQuery(const OUT_TYPE(Query, Query) msg);
static TypeName * _readTypeName(const OUT_TYPE(TypeName, TypeName) msg);
static ColumnRef * _readColumnRef(const OUT_TYPE(ColumnRef, ColumnRef) msg);
static ParamRef * _readParamRef(const OUT_TYPE(ParamRef, ParamRef) msg);
static A_Expr * _readAExpr(const OUT_TYPE(A_Expr, AExpr) msg);
static TypeCast * _readTypeCast(const OUT_TYPE(TypeCast, TypeCast) msg);
static CollateClause * _readCollateClause(const OUT_TYPE(CollateClause, CollateClause) msg);
static RoleSpec * _readRoleSpec(const OUT_TYPE(RoleSpec, RoleSpec) msg);
static FuncCall * _readFuncCall(const OUT_TYPE(FuncCall, FuncCall) msg);
static A_Star * _readAStar(const OUT_TYPE(A_Star, AStar) msg);
static A_Indices * _readAIndices(const OUT_TYPE(A_Indices, AIndices) msg);
static A_Indirection * _readAIndirection(const OUT_TYPE(A_Indirection, AIndirection) msg);
static A_ArrayExpr * _readAArrayExpr(const OUT_TYPE(A_ArrayExpr, AArrayExpr) msg);
static ResTarget * _readResTarget(const OUT_TYPE(ResTarget, ResTarget) msg);
static MultiAssignRef * _readMultiAssignRef(const OUT_TYPE(MultiAssignRef, MultiAssignRef) msg);
static SortBy * _readSortBy(const OUT_TYPE(SortBy, SortBy) msg);
static WindowDef * _readWindowDef(const OUT_TYPE(WindowDef, WindowDef) msg);
static RangeSubselect * _readRangeSubselect(const OUT_TYPE(RangeSubselect, RangeSubselect) msg);
static RangeFunction * _readRangeFunction(const OUT_TYPE(RangeFunction, RangeFunction) msg);
static RangeTableFunc * _readRangeTableFunc(const OUT_TYPE(RangeTableFunc, RangeTableFunc) msg);
static RangeTableFuncCol * _readRangeTableFuncCol(const OUT_TYPE(RangeTableFuncCol, RangeTableFuncCol) msg);
static RangeTableSample * _readRangeTableSample(const OUT_TYPE(RangeTableSample, RangeTableSample) msg);
static ColumnDef * _readColumnDef(const OUT_TYPE(ColumnDef, ColumnDef) msg);
static TableLikeClause * _readTableLikeClause(const OUT_TYPE(TableLikeClause, TableLikeClause) msg);
static IndexElem * _readIndexElem(const OUT_TYPE(IndexElem, IndexElem) msg);
static DefElem * _readDefElem(const OUT_TYPE(DefElem, DefElem) msg);
static LockingClause * _readLockingClause(const OUT_TYPE(LockingClause, LockingClause) msg);
static XmlSerialize * _readXmlSerialize(const OUT_TYPE(XmlSerialize, XmlSerialize) msg);
static PartitionElem * _readPartitionElem(const OUT_TYPE(PartitionElem, PartitionElem) msg);
static PartitionSpec * _readPartitionSpec(const OUT_TYPE(PartitionSpec, PartitionSpec) msg);
static PartitionBoundSpec * _readPartitionBoundSpec(const OUT_TYPE(PartitionBoundSpec, PartitionBoundSpec) msg);
static PartitionRangeDatum * _readPartitionRangeDatum(const OUT_TYPE(PartitionRangeDatum, PartitionRangeDatum) msg);
static PartitionCmd * _readPartitionCmd(const OUT_TYPE(PartitionCmd, PartitionCmd) msg);
static RangeTblEntry * _readRangeTblEntry(const OUT_TYPE(RangeTblEntry, RangeTblEntry) msg);
static RTEPermissionInfo * _readRTEPermissionInfo(const OUT_TYPE(RTEPermissionInfo, RTEPermissionInfo) msg);
static RangeTblFunction * _readRangeTblFunction(const OUT_TYPE(RangeTblFunction, RangeTblFunction) msg);
static TableSampleClause * _readTableSampleClause(const OUT_TYPE(TableSampleClause, TableSampleClause) msg);
static WithCheckOption * _readWithCheckOption(const OUT_TYPE(WithCheckOption, WithCheckOption) msg);
static SortGroupClause * _readSortGroupClause(const OUT_TYPE(SortGroupClause, SortGroupClause) msg);
static GroupingSet * _readGroupingSet(const OUT_TYPE(GroupingSet, GroupingSet) msg);
static WindowClause * _readWindowClause(const OUT_TYPE(WindowClause, WindowClause) msg);
static RowMarkClause * _readRowMarkClause(const OUT_TYPE(RowMarkClause, RowMarkClause) msg);
static WithClause * _readWithClause(const OUT_TYPE(WithClause, WithClause) msg);
static InferClause * _readInferClause(const OUT_TYPE(InferClause, InferClause) msg);
static OnConflictClause * _readOnConflictClause(const OUT_TYPE(OnConflictClause, OnConflictClause) msg);
static CTESearchClause * _readCTESearchClause(const OUT_TYPE(CTESearchClause, CTESearchClause) msg);
static CTECycleClause * _readCTECycleClause(const OUT_TYPE(CTECycleClause, CTECycleClause) msg);
static CommonTableExpr * _readCommonTableExpr(const OUT_TYPE(CommonTableExpr, CommonTableExpr) msg);
static MergeWhenClause * _readMergeWhenClause(const OUT_TYPE(MergeWhenClause, MergeWhenClause) msg);
static ReturningOption * _readReturningOption(const OUT_TYPE(ReturningOption, ReturningOption) msg);
static ReturningClause * _readReturningClause(const OUT_TYPE(ReturningClause, ReturningClause) msg);
static TriggerTransition * _readTriggerTransition(const OUT_TYPE(TriggerTransition, TriggerTransition) msg);
static JsonOutput * _readJsonOutput(const OUT_TYPE(JsonOutput, JsonOutput) msg);
static JsonArgument * _readJsonArgument(const OUT_TYPE(JsonArgument, JsonArgument) msg);
static JsonFuncExpr * _readJsonFuncExpr(const OUT_TYPE(JsonFuncExpr, JsonFuncExpr) msg);
static JsonTablePathSpec * _readJsonTablePathSpec(const OUT_TYPE(JsonTablePathSpec, JsonTablePathSpec) msg);
static JsonTable * _readJsonTable(const OUT_TYPE(JsonTable, JsonTable) msg);
static JsonTableColumn * _readJsonTableColumn(const OUT_TYPE(JsonTableColumn, JsonTableColumn) msg);
static JsonKeyValue * _readJsonKeyValue(const OUT_TYPE(JsonKeyValue, JsonKeyValue) msg);
static JsonParseExpr * _readJsonParseExpr(const OUT_TYPE(JsonParseExpr, JsonParseExpr) msg);
static JsonScalarExpr * _readJsonScalarExpr(const OUT_TYPE(JsonScalarExpr, JsonScalarExpr) msg);
static JsonSerializeExpr * _readJsonSerializeExpr(const OUT_TYPE(JsonSerializeExpr, JsonSerializeExpr) msg);
static JsonObjectConstructor * _readJsonObjectConstructor(const OUT_TYPE(JsonObjectConstructor, JsonObjectConstructor) msg);
static JsonArrayConstructor * _readJsonArrayConstructor(const OUT_TYPE(JsonArrayConstructor, JsonArrayConstructor) msg);
static JsonArrayQueryConstructor * _readJsonArrayQueryConstructor(const OUT_TYPE(JsonArrayQueryConstructor, JsonArrayQueryConstructor) msg);
static JsonAggConstructor * _readJsonAggConstructor(const OUT_TYPE(JsonAggConstructor, JsonAggConstructor) msg);
static JsonObjectAgg * _readJsonObjectAgg(const OUT_TYPE(JsonObjectAgg, JsonObjectAgg) msg);
static JsonArrayAgg * _readJsonArrayAgg(const OUT_TYPE(JsonArrayAgg, JsonArrayAgg) msg);
static RawStmt * _readRawStmt(const OUT_TYPE(RawStmt, RawStmt) msg);
static InsertStmt * _readInsertStmt(const OUT_TYPE(InsertStmt, InsertStmt) msg);
static DeleteStmt * _readDeleteStmt(const OUT_TYPE(DeleteStmt, DeleteStmt) msg);
static UpdateStmt * _readUpdateStmt(const OUT_TYPE(UpdateStmt, UpdateStmt) msg);
static MergeStmt * _readMergeStmt(const OUT_TYPE(MergeStmt, MergeStmt) msg);
static SelectStmt * _readSelectStmt(const OUT_TYPE(SelectStmt, SelectStmt) msg);
static SetOperationStmt * _readSetOperationStmt(const OUT_TYPE(SetOperationStmt, SetOperationStmt) msg);
static ReturnStmt * _readReturnStmt(const OUT_TYPE(ReturnStmt, ReturnStmt) msg);
static PLAssignStmt * _readPLAssignStmt(const OUT_TYPE(PLAssignStmt, PLAssignStmt) msg);
static CreateSchemaStmt * _readCreateSchemaStmt(const OUT_TYPE(CreateSchemaStmt, CreateSchemaStmt) msg);
static AlterTableStmt * _readAlterTableStmt(const OUT_TYPE(AlterTableStmt, AlterTableStmt) msg);
static AlterTableCmd * _readAlterTableCmd(const OUT_TYPE(AlterTableCmd, AlterTableCmd) msg);
static ATAlterConstraint * _readATAlterConstraint(const OUT_TYPE(ATAlterConstraint, ATAlterConstraint) msg);
static ReplicaIdentityStmt * _readReplicaIdentityStmt(const OUT_TYPE(ReplicaIdentityStmt, ReplicaIdentityStmt) msg);
static AlterCollationStmt * _readAlterCollationStmt(const OUT_TYPE(AlterCollationStmt, AlterCollationStmt) msg);
static AlterDomainStmt * _readAlterDomainStmt(const OUT_TYPE(AlterDomainStmt, AlterDomainStmt) msg);
static GrantStmt * _readGrantStmt(const OUT_TYPE(GrantStmt, GrantStmt) msg);
static ObjectWithArgs * _readObjectWithArgs(const OUT_TYPE(ObjectWithArgs, ObjectWithArgs) msg);
static AccessPriv * _readAccessPriv(const OUT_TYPE(AccessPriv, AccessPriv) msg);
static GrantRoleStmt * _readGrantRoleStmt(const OUT_TYPE(GrantRoleStmt, GrantRoleStmt) msg);
static AlterDefaultPrivilegesStmt * _readAlterDefaultPrivilegesStmt(const OUT_TYPE(AlterDefaultPrivilegesStmt, AlterDefaultPrivilegesStmt) msg);
static CopyStmt * _readCopyStmt(const OUT_TYPE(CopyStmt, CopyStmt) msg);
static VariableSetStmt * _readVariableSetStmt(const OUT_TYPE(VariableSetStmt, VariableSetStmt) msg);
static VariableShowStmt * _readVariableShowStmt(const OUT_TYPE(VariableShowStmt, VariableShowStmt) msg);
static CreateStmt * _readCreateStmt(const OUT_TYPE(CreateStmt, CreateStmt) msg);
static Constraint * _readConstraint(const OUT_TYPE(Constraint, Constraint) msg);
static CreateTableSpaceStmt * _readCreateTableSpaceStmt(const OUT_TYPE(CreateTableSpaceStmt, CreateTableSpaceStmt) msg);
static DropTableSpaceStmt * _readDropTableSpaceStmt(const OUT_TYPE(DropTableSpaceStmt, DropTableSpaceStmt) msg);
static AlterTableSpaceOptionsStmt * _readAlterTableSpaceOptionsStmt(const OUT_TYPE(AlterTableSpaceOptionsStmt, AlterTableSpaceOptionsStmt) msg);
static AlterTableMoveAllStmt * _readAlterTableMoveAllStmt(const OUT_TYPE(AlterTableMoveAllStmt, AlterTableMoveAllStmt) msg);
static CreateExtensionStmt * _readCreateExtensionStmt(const OUT_TYPE(CreateExtensionStmt, CreateExtensionStmt) msg);
static AlterExtensionStmt * _readAlterExtensionStmt(const OUT_TYPE(AlterExtensionStmt, AlterExtensionStmt) msg);
static AlterExtensionContentsStmt * _readAlterExtensionContentsStmt(const OUT_TYPE(AlterExtensionContentsStmt, AlterExtensionContentsStmt) msg);
static CreateFdwStmt * _readCreateFdwStmt(const OUT_TYPE(CreateFdwStmt, CreateFdwStmt) msg);
static AlterFdwStmt * _readAlterFdwStmt(const OUT_TYPE(AlterFdwStmt, AlterFdwStmt) msg);
static CreateForeignServerStmt * _readCreateForeignServerStmt(const OUT_TYPE(CreateForeignServerStmt, CreateForeignServerStmt) msg);
static AlterForeignServerStmt * _readAlterForeignServerStmt(const OUT_TYPE(AlterForeignServerStmt, AlterForeignServerStmt) msg);
static CreateForeignTableStmt * _readCreateForeignTableStmt(const OUT_TYPE(CreateForeignTableStmt, CreateForeignTableStmt) msg);
static CreateUserMappingStmt * _readCreateUserMappingStmt(const OUT_TYPE(CreateUserMappingStmt, CreateUserMappingStmt) msg);
static AlterUserMappingStmt * _readAlterUserMappingStmt(const OUT_TYPE(AlterUserMappingStmt, AlterUserMappingStmt) msg);
static DropUserMappingStmt * _readDropUserMappingStmt(const OUT_TYPE(DropUserMappingStmt, DropUserMappingStmt) msg);
static ImportForeignSchemaStmt * _readImportForeignSchemaStmt(const OUT_TYPE(ImportForeignSchemaStmt, ImportForeignSchemaStmt) msg);
static CreatePolicyStmt * _readCreatePolicyStmt(const OUT_TYPE(CreatePolicyStmt, CreatePolicyStmt) msg);
static AlterPolicyStmt * _readAlterPolicyStmt(const OUT_TYPE(AlterPolicyStmt, AlterPolicyStmt) msg);
static CreateAmStmt * _readCreateAmStmt(const OUT_TYPE(CreateAmStmt, CreateAmStmt) msg);
static CreateTrigStmt * _readCreateTrigStmt(const OUT_TYPE(CreateTrigStmt, CreateTrigStmt) msg);
static CreateEventTrigStmt * _readCreateEventTrigStmt(const OUT_TYPE(CreateEventTrigStmt, CreateEventTrigStmt) msg);
static AlterEventTrigStmt * _readAlterEventTrigStmt(const OUT_TYPE(AlterEventTrigStmt, AlterEventTrigStmt) msg);
static CreatePLangStmt * _readCreatePLangStmt(const OUT_TYPE(CreatePLangStmt, CreatePLangStmt) msg);
static CreateRoleStmt * _readCreateRoleStmt(const OUT_TYPE(CreateRoleStmt, CreateRoleStmt) msg);
static AlterRoleStmt * _readAlterRoleStmt(const OUT_TYPE(AlterRoleStmt, AlterRoleStmt) msg);
static AlterRoleSetStmt * _readAlterRoleSetStmt(const OUT_TYPE(AlterRoleSetStmt, AlterRoleSetStmt) msg);
static DropRoleStmt * _readDropRoleStmt(const OUT_TYPE(DropRoleStmt, DropRoleStmt) msg);
static CreateSeqStmt * _readCreateSeqStmt(const OUT_TYPE(CreateSeqStmt, CreateSeqStmt) msg);
static AlterSeqStmt * _readAlterSeqStmt(const OUT_TYPE(AlterSeqStmt, AlterSeqStmt) msg);
static DefineStmt * _readDefineStmt(const OUT_TYPE(DefineStmt, DefineStmt) msg);
static CreateDomainStmt * _readCreateDomainStmt(const OUT_TYPE(CreateDomainStmt, CreateDomainStmt) msg);
static CreateOpClassStmt * _readCreateOpClassStmt(const OUT_TYPE(CreateOpClassStmt, CreateOpClassStmt) msg);
static CreateOpClassItem * _readCreateOpClassItem(const OUT_TYPE(CreateOpClassItem, CreateOpClassItem) msg);
static CreateOpFamilyStmt * _readCreateOpFamilyStmt(const OUT_TYPE(CreateOpFamilyStmt, CreateOpFamilyStmt) msg);
static AlterOpFamilyStmt * _readAlterOpFamilyStmt(const OUT_TYPE(AlterOpFamilyStmt, AlterOpFamilyStmt) msg);
static DropStmt * _readDropStmt(const OUT_TYPE(DropStmt, DropStmt) msg);
static TruncateStmt * _readTruncateStmt(const OUT_TYPE(TruncateStmt, TruncateStmt) msg);
static CommentStmt * _readCommentStmt(const OUT_TYPE(CommentStmt, CommentStmt) msg);
static SecLabelStmt * _readSecLabelStmt(const OUT_TYPE(SecLabelStmt, SecLabelStmt) msg);
static DeclareCursorStmt * _readDeclareCursorStmt(const OUT_TYPE(DeclareCursorStmt, DeclareCursorStmt) msg);
static ClosePortalStmt * _readClosePortalStmt(const OUT_TYPE(ClosePortalStmt, ClosePortalStmt) msg);
static FetchStmt * _readFetchStmt(const OUT_TYPE(FetchStmt, FetchStmt) msg);
static IndexStmt * _readIndexStmt(const OUT_TYPE(IndexStmt, IndexStmt) msg);
static CreateStatsStmt * _readCreateStatsStmt(const OUT_TYPE(CreateStatsStmt, CreateStatsStmt) msg);
static StatsElem * _readStatsElem(const OUT_TYPE(StatsElem, StatsElem) msg);
static AlterStatsStmt * _readAlterStatsStmt(const OUT_TYPE(AlterStatsStmt, AlterStatsStmt) msg);
static CreateFunctionStmt * _readCreateFunctionStmt(const OUT_TYPE(CreateFunctionStmt, CreateFunctionStmt) msg);
static FunctionParameter * _readFunctionParameter(const OUT_TYPE(FunctionParameter, FunctionParameter) msg);
static AlterFunctionStmt * _readAlterFunctionStmt(const OUT_TYPE(AlterFunctionStmt, AlterFunctionStmt) msg);
static DoStmt * _readDoStmt(const OUT_TYPE(DoStmt, DoStmt) msg);
static InlineCodeBlock * _readInlineCodeBlock(const OUT_TYPE(InlineCodeBlock, InlineCodeBlock) msg);
static CallStmt * _readCallStmt(const OUT_TYPE(CallStmt, CallStmt) msg);
static CallContext * _readCallContext(const OUT_TYPE(CallContext, CallContext) msg);
static RenameStmt * _readRenameStmt(const OUT_TYPE(RenameStmt, RenameStmt) msg);
static AlterObjectDependsStmt * _readAlterObjectDependsStmt(const OUT_TYPE(AlterObjectDependsStmt, AlterObjectDependsStmt) msg);
static AlterObjectSchemaStmt * _readAlterObjectSchemaStmt(const OUT_TYPE(AlterObjectSchemaStmt, AlterObjectSchemaStmt) msg);
static AlterOwnerStmt * _readAlterOwnerStmt(const OUT_TYPE(AlterOwnerStmt, AlterOwnerStmt) msg);
static AlterOperatorStmt * _readAlterOperatorStmt(const OUT_TYPE(AlterOperatorStmt, AlterOperatorStmt) msg);
static AlterTypeStmt * _readAlterTypeStmt(const OUT_TYPE(AlterTypeStmt, AlterTypeStmt) msg);
static RuleStmt * _readRuleStmt(const OUT_TYPE(RuleStmt, RuleStmt) msg);
static NotifyStmt * _readNotifyStmt(const OUT_TYPE(NotifyStmt, NotifyStmt) msg);
static ListenStmt * _readListenStmt(const OUT_TYPE(ListenStmt, ListenStmt) msg);
static UnlistenStmt * _readUnlistenStmt(const OUT_TYPE(UnlistenStmt, UnlistenStmt) msg);
static TransactionStmt * _readTransactionStmt(const OUT_TYPE(TransactionStmt, TransactionStmt) msg);
static CompositeTypeStmt * _readCompositeTypeStmt(const OUT_TYPE(CompositeTypeStmt, CompositeTypeStmt) msg);
static CreateEnumStmt * _readCreateEnumStmt(const OUT_TYPE(CreateEnumStmt, CreateEnumStmt) msg);
static CreateRangeStmt * _readCreateRangeStmt(const OUT_TYPE(CreateRangeStmt, CreateRangeStmt) msg);
static AlterEnumStmt * _readAlterEnumStmt(const OUT_TYPE(AlterEnumStmt, AlterEnumStmt) msg);
static ViewStmt * _readViewStmt(const OUT_TYPE(ViewStmt, ViewStmt) msg);
static LoadStmt * _readLoadStmt(const OUT_TYPE(LoadStmt, LoadStmt) msg);
static CreatedbStmt * _readCreatedbStmt(const OUT_TYPE(CreatedbStmt, CreatedbStmt) msg);
static AlterDatabaseStmt * _readAlterDatabaseStmt(const OUT_TYPE(AlterDatabaseStmt, AlterDatabaseStmt) msg);
static AlterDatabaseRefreshCollStmt * _readAlterDatabaseRefreshCollStmt(const OUT_TYPE(AlterDatabaseRefreshCollStmt, AlterDatabaseRefreshCollStmt) msg);
static AlterDatabaseSetStmt * _readAlterDatabaseSetStmt(const OUT_TYPE(AlterDatabaseSetStmt, AlterDatabaseSetStmt) msg);
static DropdbStmt * _readDropdbStmt(const OUT_TYPE(DropdbStmt, DropdbStmt) msg);
static AlterSystemStmt * _readAlterSystemStmt(const OUT_TYPE(AlterSystemStmt, AlterSystemStmt) msg);
static ClusterStmt * _readClusterStmt(const OUT_TYPE(ClusterStmt, ClusterStmt) msg);
static VacuumStmt * _readVacuumStmt(const OUT_TYPE(VacuumStmt, VacuumStmt) msg);
static VacuumRelation * _readVacuumRelation(const OUT_TYPE(VacuumRelation, VacuumRelation) msg);
static ExplainStmt * _readExplainStmt(const OUT_TYPE(ExplainStmt, ExplainStmt) msg);
static CreateTableAsStmt * _readCreateTableAsStmt(const OUT_TYPE(CreateTableAsStmt, CreateTableAsStmt) msg);
static RefreshMatViewStmt * _readRefreshMatViewStmt(const OUT_TYPE(RefreshMatViewStmt, RefreshMatViewStmt) msg);
static CheckPointStmt * _readCheckPointStmt(const OUT_TYPE(CheckPointStmt, CheckPointStmt) msg);
static DiscardStmt * _readDiscardStmt(const OUT_TYPE(DiscardStmt, DiscardStmt) msg);
static LockStmt * _readLockStmt(const OUT_TYPE(LockStmt, LockStmt) msg);
static ConstraintsSetStmt * _readConstraintsSetStmt(const OUT_TYPE(ConstraintsSetStmt, ConstraintsSetStmt) msg);
static ReindexStmt * _readReindexStmt(const OUT_TYPE(ReindexStmt, ReindexStmt) msg);
static CreateConversionStmt * _readCreateConversionStmt(const OUT_TYPE(CreateConversionStmt, CreateConversionStmt) msg);
static CreateCastStmt * _readCreateCastStmt(const OUT_TYPE(CreateCastStmt, CreateCastStmt) msg);
static CreateTransformStmt * _readCreateTransformStmt(const OUT_TYPE(CreateTransformStmt, CreateTransformStmt) msg);
static PrepareStmt * _readPrepareStmt(const OUT_TYPE(PrepareStmt, PrepareStmt) msg);
static ExecuteStmt * _readExecuteStmt(const OUT_TYPE(ExecuteStmt, ExecuteStmt) msg);
static DeallocateStmt * _readDeallocateStmt(const OUT_TYPE(DeallocateStmt, DeallocateStmt) msg);
static DropOwnedStmt * _readDropOwnedStmt(const OUT_TYPE(DropOwnedStmt, DropOwnedStmt) msg);
static ReassignOwnedStmt * _readReassignOwnedStmt(const OUT_TYPE(ReassignOwnedStmt, ReassignOwnedStmt) msg);
static AlterTSDictionaryStmt * _readAlterTSDictionaryStmt(const OUT_TYPE(AlterTSDictionaryStmt, AlterTSDictionaryStmt) msg);
static AlterTSConfigurationStmt * _readAlterTSConfigurationStmt(const OUT_TYPE(AlterTSConfigurationStmt, AlterTSConfigurationStmt) msg);
static PublicationTable * _readPublicationTable(const OUT_TYPE(PublicationTable, PublicationTable) msg);
static PublicationObjSpec * _readPublicationObjSpec(const OUT_TYPE(PublicationObjSpec, PublicationObjSpec) msg);
static CreatePublicationStmt * _readCreatePublicationStmt(const OUT_TYPE(CreatePublicationStmt, CreatePublicationStmt) msg);
static AlterPublicationStmt * _readAlterPublicationStmt(const OUT_TYPE(AlterPublicationStmt, AlterPublicationStmt) msg);
static CreateSubscriptionStmt * _readCreateSubscriptionStmt(const OUT_TYPE(CreateSubscriptionStmt, CreateSubscriptionStmt) msg);
static AlterSubscriptionStmt * _readAlterSubscriptionStmt(const OUT_TYPE(AlterSubscriptionStmt, AlterSubscriptionStmt) msg);
static DropSubscriptionStmt * _readDropSubscriptionStmt(const OUT_TYPE(DropSubscriptionStmt, DropSubscriptionStmt) msg);


static Alias *
_readAlias(const OUT_TYPE(Alias, Alias) msg)
{
  Alias *node = makeNode(Alias);
  READ_STRING_FIELD(Alias, aliasname, aliasname, aliasname);
  READ_LIST_FIELD(Alias, colnames, colnames, colnames);
  return node;
}

static RangeVar *
_readRangeVar(const OUT_TYPE(RangeVar, RangeVar) msg)
{
  RangeVar *node = makeNode(RangeVar);
  READ_STRING_FIELD(RangeVar, catalogname, catalogname, catalogname);
  READ_STRING_FIELD(RangeVar, schemaname, schemaname, schemaname);
  READ_STRING_FIELD(RangeVar, relname, relname, relname);
  READ_BOOL_FIELD(RangeVar, inh, inh, inh);
  READ_CHAR_FIELD(RangeVar, relpersistence, relpersistence, relpersistence);
  READ_SPECIFIC_NODE_PTR_FIELD(RangeVar, Alias, alias, alias, alias, alias);
  READ_INT_FIELD(RangeVar, location, location, location);
  return node;
}

static TableFunc *
_readTableFunc(const OUT_TYPE(TableFunc, TableFunc) msg)
{
  TableFunc *node = makeNode(TableFunc);
  READ_ENUM_FIELD(TableFunc, TableFuncType, functype, functype, functype);
  READ_LIST_FIELD(TableFunc, ns_uris, ns_uris, ns_uris);
  READ_LIST_FIELD(TableFunc, ns_names, ns_names, ns_names);
  READ_NODE_PTR_FIELD(TableFunc, docexpr, docexpr, docexpr);
  READ_NODE_PTR_FIELD(TableFunc, rowexpr, rowexpr, rowexpr);
  READ_LIST_FIELD(TableFunc, colnames, colnames, colnames);
  READ_LIST_FIELD(TableFunc, coltypes, coltypes, coltypes);
  READ_LIST_FIELD(TableFunc, coltypmods, coltypmods, coltypmods);
  READ_LIST_FIELD(TableFunc, colcollations, colcollations, colcollations);
  READ_LIST_FIELD(TableFunc, colexprs, colexprs, colexprs);
  READ_LIST_FIELD(TableFunc, coldefexprs, coldefexprs, coldefexprs);
  READ_LIST_FIELD(TableFunc, colvalexprs, colvalexprs, colvalexprs);
  READ_LIST_FIELD(TableFunc, passingvalexprs, passingvalexprs, passingvalexprs);
  READ_BITMAPSET_FIELD(TableFunc, notnulls, notnulls, notnulls);
  READ_NODE_PTR_FIELD(TableFunc, plan, plan, plan);
  READ_INT_FIELD(TableFunc, ordinalitycol, ordinalitycol, ordinalitycol);
  READ_INT_FIELD(TableFunc, location, location, location);
  return node;
}

static IntoClause *
_readIntoClause(const OUT_TYPE(IntoClause, IntoClause) msg)
{
  IntoClause *node = makeNode(IntoClause);
  READ_SPECIFIC_NODE_PTR_FIELD(IntoClause, RangeVar, range_var, rel, rel, rel);
  READ_LIST_FIELD(IntoClause, col_names, colNames, colNames);
  READ_STRING_FIELD(IntoClause, access_method, accessMethod, accessMethod);
  READ_LIST_FIELD(IntoClause, options, options, options);
  READ_ENUM_FIELD(IntoClause, OnCommitAction, on_commit, onCommit, onCommit);
  READ_STRING_FIELD(IntoClause, table_space_name, tableSpaceName, tableSpaceName);
  READ_SPECIFIC_NODE_PTR_FIELD(IntoClause, Query, query, view_query, viewQuery, viewQuery);
  READ_BOOL_FIELD(IntoClause, skip_data, skipData, skipData);
  return node;
}

static Var *
_readVar(const OUT_TYPE(Var, Var) msg)
{
  Var *node = makeNode(Var);
  READ_INT_FIELD(Var, varno, varno, varno);
  READ_INT_FIELD(Var, varattno, varattno, varattno);
  READ_UINT_FIELD(Var, vartype, vartype, vartype);
  READ_INT_FIELD(Var, vartypmod, vartypmod, vartypmod);
  READ_UINT_FIELD(Var, varcollid, varcollid, varcollid);
  READ_BITMAPSET_FIELD(Var, varnullingrels, varnullingrels, varnullingrels);
  READ_UINT_FIELD(Var, varlevelsup, varlevelsup, varlevelsup);
  READ_ENUM_FIELD(Var, VarReturningType, varreturningtype, varreturningtype, varreturningtype);
  READ_INT_FIELD(Var, location, location, location);
  return node;
}

static Param *
_readParam(const OUT_TYPE(Param, Param) msg)
{
  Param *node = makeNode(Param);
  READ_ENUM_FIELD(Param, ParamKind, paramkind, paramkind, paramkind);
  READ_INT_FIELD(Param, paramid, paramid, paramid);
  READ_UINT_FIELD(Param, paramtype, paramtype, paramtype);
  READ_INT_FIELD(Param, paramtypmod, paramtypmod, paramtypmod);
  READ_UINT_FIELD(Param, paramcollid, paramcollid, paramcollid);
  READ_INT_FIELD(Param, location, location, location);
  return node;
}

static Aggref *
_readAggref(const OUT_TYPE(Aggref, Aggref) msg)
{
  Aggref *node = makeNode(Aggref);
  READ_UINT_FIELD(Aggref, aggfnoid, aggfnoid, aggfnoid);
  READ_UINT_FIELD(Aggref, aggtype, aggtype, aggtype);
  READ_UINT_FIELD(Aggref, aggcollid, aggcollid, aggcollid);
  READ_UINT_FIELD(Aggref, inputcollid, inputcollid, inputcollid);
  READ_LIST_FIELD(Aggref, aggargtypes, aggargtypes, aggargtypes);
  READ_LIST_FIELD(Aggref, aggdirectargs, aggdirectargs, aggdirectargs);
  READ_LIST_FIELD(Aggref, args, args, args);
  READ_LIST_FIELD(Aggref, aggorder, aggorder, aggorder);
  READ_LIST_FIELD(Aggref, aggdistinct, aggdistinct, aggdistinct);
  READ_ABSTRACT_PTR_FIELD(Aggref, aggfilter, aggfilter, aggfilter, Expr*);
  READ_BOOL_FIELD(Aggref, aggstar, aggstar, aggstar);
  READ_BOOL_FIELD(Aggref, aggvariadic, aggvariadic, aggvariadic);
  READ_CHAR_FIELD(Aggref, aggkind, aggkind, aggkind);
  READ_UINT_FIELD(Aggref, agglevelsup, agglevelsup, agglevelsup);
  READ_ENUM_FIELD(Aggref, AggSplit, aggsplit, aggsplit, aggsplit);
  READ_INT_FIELD(Aggref, aggno, aggno, aggno);
  READ_INT_FIELD(Aggref, aggtransno, aggtransno, aggtransno);
  READ_INT_FIELD(Aggref, location, location, location);
  return node;
}

static GroupingFunc *
_readGroupingFunc(const OUT_TYPE(GroupingFunc, GroupingFunc) msg)
{
  GroupingFunc *node = makeNode(GroupingFunc);
  READ_LIST_FIELD(GroupingFunc, args, args, args);
  READ_LIST_FIELD(GroupingFunc, refs, refs, refs);
  READ_UINT_FIELD(GroupingFunc, agglevelsup, agglevelsup, agglevelsup);
  READ_INT_FIELD(GroupingFunc, location, location, location);
  return node;
}

static WindowFunc *
_readWindowFunc(const OUT_TYPE(WindowFunc, WindowFunc) msg)
{
  WindowFunc *node = makeNode(WindowFunc);
  READ_UINT_FIELD(WindowFunc, winfnoid, winfnoid, winfnoid);
  READ_UINT_FIELD(WindowFunc, wintype, wintype, wintype);
  READ_UINT_FIELD(WindowFunc, wincollid, wincollid, wincollid);
  READ_UINT_FIELD(WindowFunc, inputcollid, inputcollid, inputcollid);
  READ_LIST_FIELD(WindowFunc, args, args, args);
  READ_ABSTRACT_PTR_FIELD(WindowFunc, aggfilter, aggfilter, aggfilter, Expr*);
  READ_LIST_FIELD(WindowFunc, run_condition, runCondition, runCondition);
  READ_UINT_FIELD(WindowFunc, winref, winref, winref);
  READ_BOOL_FIELD(WindowFunc, winstar, winstar, winstar);
  READ_BOOL_FIELD(WindowFunc, winagg, winagg, winagg);
  READ_INT_FIELD(WindowFunc, location, location, location);
  return node;
}

static WindowFuncRunCondition *
_readWindowFuncRunCondition(const OUT_TYPE(WindowFuncRunCondition, WindowFuncRunCondition) msg)
{
  WindowFuncRunCondition *node = makeNode(WindowFuncRunCondition);
  READ_UINT_FIELD(WindowFuncRunCondition, opno, opno, opno);
  READ_UINT_FIELD(WindowFuncRunCondition, inputcollid, inputcollid, inputcollid);
  READ_BOOL_FIELD(WindowFuncRunCondition, wfunc_left, wfunc_left, wfunc_left);
  READ_ABSTRACT_PTR_FIELD(WindowFuncRunCondition, arg, arg, arg, Expr*);
  return node;
}

static MergeSupportFunc *
_readMergeSupportFunc(const OUT_TYPE(MergeSupportFunc, MergeSupportFunc) msg)
{
  MergeSupportFunc *node = makeNode(MergeSupportFunc);
  READ_UINT_FIELD(MergeSupportFunc, msftype, msftype, msftype);
  READ_UINT_FIELD(MergeSupportFunc, msfcollid, msfcollid, msfcollid);
  READ_INT_FIELD(MergeSupportFunc, location, location, location);
  return node;
}

static SubscriptingRef *
_readSubscriptingRef(const OUT_TYPE(SubscriptingRef, SubscriptingRef) msg)
{
  SubscriptingRef *node = makeNode(SubscriptingRef);
  READ_UINT_FIELD(SubscriptingRef, refcontainertype, refcontainertype, refcontainertype);
  READ_UINT_FIELD(SubscriptingRef, refelemtype, refelemtype, refelemtype);
  READ_UINT_FIELD(SubscriptingRef, refrestype, refrestype, refrestype);
  READ_INT_FIELD(SubscriptingRef, reftypmod, reftypmod, reftypmod);
  READ_UINT_FIELD(SubscriptingRef, refcollid, refcollid, refcollid);
  READ_LIST_FIELD(SubscriptingRef, refupperindexpr, refupperindexpr, refupperindexpr);
  READ_LIST_FIELD(SubscriptingRef, reflowerindexpr, reflowerindexpr, reflowerindexpr);
  READ_ABSTRACT_PTR_FIELD(SubscriptingRef, refexpr, refexpr, refexpr, Expr*);
  READ_ABSTRACT_PTR_FIELD(SubscriptingRef, refassgnexpr, refassgnexpr, refassgnexpr, Expr*);
  return node;
}

static FuncExpr *
_readFuncExpr(const OUT_TYPE(FuncExpr, FuncExpr) msg)
{
  FuncExpr *node = makeNode(FuncExpr);
  READ_UINT_FIELD(FuncExpr, funcid, funcid, funcid);
  READ_UINT_FIELD(FuncExpr, funcresulttype, funcresulttype, funcresulttype);
  READ_BOOL_FIELD(FuncExpr, funcretset, funcretset, funcretset);
  READ_BOOL_FIELD(FuncExpr, funcvariadic, funcvariadic, funcvariadic);
  READ_ENUM_FIELD(FuncExpr, CoercionForm, funcformat, funcformat, funcformat);
  READ_UINT_FIELD(FuncExpr, funccollid, funccollid, funccollid);
  READ_UINT_FIELD(FuncExpr, inputcollid, inputcollid, inputcollid);
  READ_LIST_FIELD(FuncExpr, args, args, args);
  READ_INT_FIELD(FuncExpr, location, location, location);
  return node;
}

static NamedArgExpr *
_readNamedArgExpr(const OUT_TYPE(NamedArgExpr, NamedArgExpr) msg)
{
  NamedArgExpr *node = makeNode(NamedArgExpr);
  READ_ABSTRACT_PTR_FIELD(NamedArgExpr, arg, arg, arg, Expr*);
  READ_STRING_FIELD(NamedArgExpr, name, name, name);
  READ_INT_FIELD(NamedArgExpr, argnumber, argnumber, argnumber);
  READ_INT_FIELD(NamedArgExpr, location, location, location);
  return node;
}

static OpExpr *
_readOpExpr(const OUT_TYPE(OpExpr, OpExpr) msg)
{
  OpExpr *node = makeNode(OpExpr);
  READ_UINT_FIELD(OpExpr, opno, opno, opno);
  READ_UINT_FIELD(OpExpr, opresulttype, opresulttype, opresulttype);
  READ_BOOL_FIELD(OpExpr, opretset, opretset, opretset);
  READ_UINT_FIELD(OpExpr, opcollid, opcollid, opcollid);
  READ_UINT_FIELD(OpExpr, inputcollid, inputcollid, inputcollid);
  READ_LIST_FIELD(OpExpr, args, args, args);
  READ_INT_FIELD(OpExpr, location, location, location);
  return node;
}

static DistinctExpr *
_readDistinctExpr(const OUT_TYPE(DistinctExpr, DistinctExpr) msg)
{
  DistinctExpr *node = makeNode(DistinctExpr);
  READ_UINT_FIELD(DistinctExpr, opno, opno, opno);
  READ_UINT_FIELD(DistinctExpr, opresulttype, opresulttype, opresulttype);
  READ_BOOL_FIELD(DistinctExpr, opretset, opretset, opretset);
  READ_UINT_FIELD(DistinctExpr, opcollid, opcollid, opcollid);
  READ_UINT_FIELD(DistinctExpr, inputcollid, inputcollid, inputcollid);
  READ_LIST_FIELD(DistinctExpr, args, args, args);
  READ_INT_FIELD(DistinctExpr, location, location, location);
  return node;
}

static NullIfExpr *
_readNullIfExpr(const OUT_TYPE(NullIfExpr, NullIfExpr) msg)
{
  NullIfExpr *node = makeNode(NullIfExpr);
  READ_UINT_FIELD(NullIfExpr, opno, opno, opno);
  READ_UINT_FIELD(NullIfExpr, opresulttype, opresulttype, opresulttype);
  READ_BOOL_FIELD(NullIfExpr, opretset, opretset, opretset);
  READ_UINT_FIELD(NullIfExpr, opcollid, opcollid, opcollid);
  READ_UINT_FIELD(NullIfExpr, inputcollid, inputcollid, inputcollid);
  READ_LIST_FIELD(NullIfExpr, args, args, args);
  READ_INT_FIELD(NullIfExpr, location, location, location);
  return node;
}

static ScalarArrayOpExpr *
_readScalarArrayOpExpr(const OUT_TYPE(ScalarArrayOpExpr, ScalarArrayOpExpr) msg)
{
  ScalarArrayOpExpr *node = makeNode(ScalarArrayOpExpr);
  READ_UINT_FIELD(ScalarArrayOpExpr, opno, opno, opno);
  READ_BOOL_FIELD(ScalarArrayOpExpr, use_or, useOr, useOr);
  READ_UINT_FIELD(ScalarArrayOpExpr, inputcollid, inputcollid, inputcollid);
  READ_LIST_FIELD(ScalarArrayOpExpr, args, args, args);
  READ_INT_FIELD(ScalarArrayOpExpr, location, location, location);
  return node;
}

static BoolExpr *
_readBoolExpr(const OUT_TYPE(BoolExpr, BoolExpr) msg)
{
  BoolExpr *node = makeNode(BoolExpr);
  READ_ENUM_FIELD(BoolExpr, BoolExprType, boolop, boolop, boolop);
  READ_LIST_FIELD(BoolExpr, args, args, args);
  READ_INT_FIELD(BoolExpr, location, location, location);
  return node;
}

static SubLink *
_readSubLink(const OUT_TYPE(SubLink, SubLink) msg)
{
  SubLink *node = makeNode(SubLink);
  READ_ENUM_FIELD(SubLink, SubLinkType, sub_link_type, subLinkType, subLinkType);
  READ_INT_FIELD(SubLink, sub_link_id, subLinkId, subLinkId);
  READ_NODE_PTR_FIELD(SubLink, testexpr, testexpr, testexpr);
  READ_LIST_FIELD(SubLink, oper_name, operName, operName);
  READ_NODE_PTR_FIELD(SubLink, subselect, subselect, subselect);
  READ_INT_FIELD(SubLink, location, location, location);
  return node;
}

static SubPlan *
_readSubPlan(const OUT_TYPE(SubPlan, SubPlan) msg)
{
  SubPlan *node = makeNode(SubPlan);
  READ_ENUM_FIELD(SubPlan, SubLinkType, sub_link_type, subLinkType, subLinkType);
  READ_NODE_PTR_FIELD(SubPlan, testexpr, testexpr, testexpr);
  READ_LIST_FIELD(SubPlan, param_ids, paramIds, paramIds);
  READ_INT_FIELD(SubPlan, plan_id, plan_id, plan_id);
  READ_STRING_FIELD(SubPlan, plan_name, plan_name, plan_name);
  READ_UINT_FIELD(SubPlan, first_col_type, firstColType, firstColType);
  READ_INT_FIELD(SubPlan, first_col_typmod, firstColTypmod, firstColTypmod);
  READ_UINT_FIELD(SubPlan, first_col_collation, firstColCollation, firstColCollation);
  READ_BOOL_FIELD(SubPlan, use_hash_table, useHashTable, useHashTable);
  READ_BOOL_FIELD(SubPlan, unknown_eq_false, unknownEqFalse, unknownEqFalse);
  READ_BOOL_FIELD(SubPlan, parallel_safe, parallel_safe, parallel_safe);
  READ_LIST_FIELD(SubPlan, set_param, setParam, setParam);
  READ_LIST_FIELD(SubPlan, par_param, parParam, parParam);
  READ_LIST_FIELD(SubPlan, args, args, args);
  READ_FLOAT_FIELD(SubPlan, startup_cost, startup_cost, startup_cost);
  READ_FLOAT_FIELD(SubPlan, per_call_cost, per_call_cost, per_call_cost);
  return node;
}

static AlternativeSubPlan *
_readAlternativeSubPlan(const OUT_TYPE(AlternativeSubPlan, AlternativeSubPlan) msg)
{
  AlternativeSubPlan *node = makeNode(AlternativeSubPlan);
  READ_LIST_FIELD(AlternativeSubPlan, subplans, subplans, subplans);
  return node;
}

static FieldSelect *
_readFieldSelect(const OUT_TYPE(FieldSelect, FieldSelect) msg)
{
  FieldSelect *node = makeNode(FieldSelect);
  READ_ABSTRACT_PTR_FIELD(FieldSelect, arg, arg, arg, Expr*);
  READ_INT_FIELD(FieldSelect, fieldnum, fieldnum, fieldnum);
  READ_UINT_FIELD(FieldSelect, resulttype, resulttype, resulttype);
  READ_INT_FIELD(FieldSelect, resulttypmod, resulttypmod, resulttypmod);
  READ_UINT_FIELD(FieldSelect, resultcollid, resultcollid, resultcollid);
  return node;
}

static FieldStore *
_readFieldStore(const OUT_TYPE(FieldStore, FieldStore) msg)
{
  FieldStore *node = makeNode(FieldStore);
  READ_ABSTRACT_PTR_FIELD(FieldStore, arg, arg, arg, Expr*);
  READ_LIST_FIELD(FieldStore, newvals, newvals, newvals);
  READ_LIST_FIELD(FieldStore, fieldnums, fieldnums, fieldnums);
  READ_UINT_FIELD(FieldStore, resulttype, resulttype, resulttype);
  return node;
}

static RelabelType *
_readRelabelType(const OUT_TYPE(RelabelType, RelabelType) msg)
{
  RelabelType *node = makeNode(RelabelType);
  READ_ABSTRACT_PTR_FIELD(RelabelType, arg, arg, arg, Expr*);
  READ_UINT_FIELD(RelabelType, resulttype, resulttype, resulttype);
  READ_INT_FIELD(RelabelType, resulttypmod, resulttypmod, resulttypmod);
  READ_UINT_FIELD(RelabelType, resultcollid, resultcollid, resultcollid);
  READ_ENUM_FIELD(RelabelType, CoercionForm, relabelformat, relabelformat, relabelformat);
  READ_INT_FIELD(RelabelType, location, location, location);
  return node;
}

static CoerceViaIO *
_readCoerceViaIO(const OUT_TYPE(CoerceViaIO, CoerceViaIO) msg)
{
  CoerceViaIO *node = makeNode(CoerceViaIO);
  READ_ABSTRACT_PTR_FIELD(CoerceViaIO, arg, arg, arg, Expr*);
  READ_UINT_FIELD(CoerceViaIO, resulttype, resulttype, resulttype);
  READ_UINT_FIELD(CoerceViaIO, resultcollid, resultcollid, resultcollid);
  READ_ENUM_FIELD(CoerceViaIO, CoercionForm, coerceformat, coerceformat, coerceformat);
  READ_INT_FIELD(CoerceViaIO, location, location, location);
  return node;
}

static ArrayCoerceExpr *
_readArrayCoerceExpr(const OUT_TYPE(ArrayCoerceExpr, ArrayCoerceExpr) msg)
{
  ArrayCoerceExpr *node = makeNode(ArrayCoerceExpr);
  READ_ABSTRACT_PTR_FIELD(ArrayCoerceExpr, arg, arg, arg, Expr*);
  READ_ABSTRACT_PTR_FIELD(ArrayCoerceExpr, elemexpr, elemexpr, elemexpr, Expr*);
  READ_UINT_FIELD(ArrayCoerceExpr, resulttype, resulttype, resulttype);
  READ_INT_FIELD(ArrayCoerceExpr, resulttypmod, resulttypmod, resulttypmod);
  READ_UINT_FIELD(ArrayCoerceExpr, resultcollid, resultcollid, resultcollid);
  READ_ENUM_FIELD(ArrayCoerceExpr, CoercionForm, coerceformat, coerceformat, coerceformat);
  READ_INT_FIELD(ArrayCoerceExpr, location, location, location);
  return node;
}

static ConvertRowtypeExpr *
_readConvertRowtypeExpr(const OUT_TYPE(ConvertRowtypeExpr, ConvertRowtypeExpr) msg)
{
  ConvertRowtypeExpr *node = makeNode(ConvertRowtypeExpr);
  READ_ABSTRACT_PTR_FIELD(ConvertRowtypeExpr, arg, arg, arg, Expr*);
  READ_UINT_FIELD(ConvertRowtypeExpr, resulttype, resulttype, resulttype);
  READ_ENUM_FIELD(ConvertRowtypeExpr, CoercionForm, convertformat, convertformat, convertformat);
  READ_INT_FIELD(ConvertRowtypeExpr, location, location, location);
  return node;
}

static CollateExpr *
_readCollateExpr(const OUT_TYPE(CollateExpr, CollateExpr) msg)
{
  CollateExpr *node = makeNode(CollateExpr);
  READ_ABSTRACT_PTR_FIELD(CollateExpr, arg, arg, arg, Expr*);
  READ_UINT_FIELD(CollateExpr, coll_oid, collOid, collOid);
  READ_INT_FIELD(CollateExpr, location, location, location);
  return node;
}

static CaseExpr *
_readCaseExpr(const OUT_TYPE(CaseExpr, CaseExpr) msg)
{
  CaseExpr *node = makeNode(CaseExpr);
  READ_UINT_FIELD(CaseExpr, casetype, casetype, casetype);
  READ_UINT_FIELD(CaseExpr, casecollid, casecollid, casecollid);
  READ_ABSTRACT_PTR_FIELD(CaseExpr, arg, arg, arg, Expr*);
  READ_LIST_FIELD(CaseExpr, args, args, args);
  READ_ABSTRACT_PTR_FIELD(CaseExpr, defresult, defresult, defresult, Expr*);
  READ_INT_FIELD(CaseExpr, location, location, location);
  return node;
}

static CaseWhen *
_readCaseWhen(const OUT_TYPE(CaseWhen, CaseWhen) msg)
{
  CaseWhen *node = makeNode(CaseWhen);
  READ_ABSTRACT_PTR_FIELD(CaseWhen, expr, expr, expr, Expr*);
  READ_ABSTRACT_PTR_FIELD(CaseWhen, result, result, result, Expr*);
  READ_INT_FIELD(CaseWhen, location, location, location);
  return node;
}

static CaseTestExpr *
_readCaseTestExpr(const OUT_TYPE(CaseTestExpr, CaseTestExpr) msg)
{
  CaseTestExpr *node = makeNode(CaseTestExpr);
  READ_UINT_FIELD(CaseTestExpr, type_id, typeId, typeId);
  READ_INT_FIELD(CaseTestExpr, type_mod, typeMod, typeMod);
  READ_UINT_FIELD(CaseTestExpr, collation, collation, collation);
  return node;
}

static ArrayExpr *
_readArrayExpr(const OUT_TYPE(ArrayExpr, ArrayExpr) msg)
{
  ArrayExpr *node = makeNode(ArrayExpr);
  READ_UINT_FIELD(ArrayExpr, array_typeid, array_typeid, array_typeid);
  READ_UINT_FIELD(ArrayExpr, array_collid, array_collid, array_collid);
  READ_UINT_FIELD(ArrayExpr, element_typeid, element_typeid, element_typeid);
  READ_LIST_FIELD(ArrayExpr, elements, elements, elements);
  READ_BOOL_FIELD(ArrayExpr, multidims, multidims, multidims);
  READ_INT_FIELD(ArrayExpr, list_start, list_start, list_start);
  READ_INT_FIELD(ArrayExpr, list_end, list_end, list_end);
  READ_INT_FIELD(ArrayExpr, location, location, location);
  return node;
}

static RowExpr *
_readRowExpr(const OUT_TYPE(RowExpr, RowExpr) msg)
{
  RowExpr *node = makeNode(RowExpr);
  READ_LIST_FIELD(RowExpr, args, args, args);
  READ_UINT_FIELD(RowExpr, row_typeid, row_typeid, row_typeid);
  READ_ENUM_FIELD(RowExpr, CoercionForm, row_format, row_format, row_format);
  READ_LIST_FIELD(RowExpr, colnames, colnames, colnames);
  READ_INT_FIELD(RowExpr, location, location, location);
  return node;
}

static RowCompareExpr *
_readRowCompareExpr(const OUT_TYPE(RowCompareExpr, RowCompareExpr) msg)
{
  RowCompareExpr *node = makeNode(RowCompareExpr);
  READ_ENUM_FIELD(RowCompareExpr, CompareType, cmptype, cmptype, cmptype);
  READ_LIST_FIELD(RowCompareExpr, opnos, opnos, opnos);
  READ_LIST_FIELD(RowCompareExpr, opfamilies, opfamilies, opfamilies);
  READ_LIST_FIELD(RowCompareExpr, inputcollids, inputcollids, inputcollids);
  READ_LIST_FIELD(RowCompareExpr, largs, largs, largs);
  READ_LIST_FIELD(RowCompareExpr, rargs, rargs, rargs);
  return node;
}

static CoalesceExpr *
_readCoalesceExpr(const OUT_TYPE(CoalesceExpr, CoalesceExpr) msg)
{
  CoalesceExpr *node = makeNode(CoalesceExpr);
  READ_UINT_FIELD(CoalesceExpr, coalescetype, coalescetype, coalescetype);
  READ_UINT_FIELD(CoalesceExpr, coalescecollid, coalescecollid, coalescecollid);
  READ_LIST_FIELD(CoalesceExpr, args, args, args);
  READ_INT_FIELD(CoalesceExpr, location, location, location);
  return node;
}

static MinMaxExpr *
_readMinMaxExpr(const OUT_TYPE(MinMaxExpr, MinMaxExpr) msg)
{
  MinMaxExpr *node = makeNode(MinMaxExpr);
  READ_UINT_FIELD(MinMaxExpr, minmaxtype, minmaxtype, minmaxtype);
  READ_UINT_FIELD(MinMaxExpr, minmaxcollid, minmaxcollid, minmaxcollid);
  READ_UINT_FIELD(MinMaxExpr, inputcollid, inputcollid, inputcollid);
  READ_ENUM_FIELD(MinMaxExpr, MinMaxOp, op, op, op);
  READ_LIST_FIELD(MinMaxExpr, args, args, args);
  READ_INT_FIELD(MinMaxExpr, location, location, location);
  return node;
}

static SQLValueFunction *
_readSQLValueFunction(const OUT_TYPE(SQLValueFunction, SQLValueFunction) msg)
{
  SQLValueFunction *node = makeNode(SQLValueFunction);
  READ_ENUM_FIELD(SQLValueFunction, SQLValueFunctionOp, op, op, op);
  READ_UINT_FIELD(SQLValueFunction, type, type, type);
  READ_INT_FIELD(SQLValueFunction, typmod, typmod, typmod);
  READ_INT_FIELD(SQLValueFunction, location, location, location);
  return node;
}

static XmlExpr *
_readXmlExpr(const OUT_TYPE(XmlExpr, XmlExpr) msg)
{
  XmlExpr *node = makeNode(XmlExpr);
  READ_ENUM_FIELD(XmlExpr, XmlExprOp, op, op, op);
  READ_STRING_FIELD(XmlExpr, name, name, name);
  READ_LIST_FIELD(XmlExpr, named_args, named_args, named_args);
  READ_LIST_FIELD(XmlExpr, arg_names, arg_names, arg_names);
  READ_LIST_FIELD(XmlExpr, args, args, args);
  READ_ENUM_FIELD(XmlExpr, XmlOptionType, xmloption, xmloption, xmloption);
  READ_BOOL_FIELD(XmlExpr, indent, indent, indent);
  READ_UINT_FIELD(XmlExpr, type, type, type);
  READ_INT_FIELD(XmlExpr, typmod, typmod, typmod);
  READ_INT_FIELD(XmlExpr, location, location, location);
  return node;
}

static JsonFormat *
_readJsonFormat(const OUT_TYPE(JsonFormat, JsonFormat) msg)
{
  JsonFormat *node = makeNode(JsonFormat);
  READ_ENUM_FIELD(JsonFormat, JsonFormatType, format_type, format_type, format_type);
  READ_ENUM_FIELD(JsonFormat, JsonEncoding, encoding, encoding, encoding);
  READ_INT_FIELD(JsonFormat, location, location, location);
  return node;
}

static JsonReturning *
_readJsonReturning(const OUT_TYPE(JsonReturning, JsonReturning) msg)
{
  JsonReturning *node = makeNode(JsonReturning);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonReturning, JsonFormat, json_format, format, format, format);
  READ_UINT_FIELD(JsonReturning, typid, typid, typid);
  READ_INT_FIELD(JsonReturning, typmod, typmod, typmod);
  return node;
}

static JsonValueExpr *
_readJsonValueExpr(const OUT_TYPE(JsonValueExpr, JsonValueExpr) msg)
{
  JsonValueExpr *node = makeNode(JsonValueExpr);
  READ_ABSTRACT_PTR_FIELD(JsonValueExpr, raw_expr, raw_expr, raw_expr, Expr*);
  READ_ABSTRACT_PTR_FIELD(JsonValueExpr, formatted_expr, formatted_expr, formatted_expr, Expr*);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonValueExpr, JsonFormat, json_format, format, format, format);
  return node;
}

static JsonConstructorExpr *
_readJsonConstructorExpr(const OUT_TYPE(JsonConstructorExpr, JsonConstructorExpr) msg)
{
  JsonConstructorExpr *node = makeNode(JsonConstructorExpr);
  READ_ENUM_FIELD(JsonConstructorExpr, JsonConstructorType, type, type, type);
  READ_LIST_FIELD(JsonConstructorExpr, args, args, args);
  READ_ABSTRACT_PTR_FIELD(JsonConstructorExpr, func, func, func, Expr*);
  READ_ABSTRACT_PTR_FIELD(JsonConstructorExpr, coercion, coercion, coercion, Expr*);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonConstructorExpr, JsonReturning, json_returning, returning, returning, returning);
  READ_BOOL_FIELD(JsonConstructorExpr, absent_on_null, absent_on_null, absent_on_null);
  READ_BOOL_FIELD(JsonConstructorExpr, unique, unique, unique);
  READ_INT_FIELD(JsonConstructorExpr, location, location, location);
  return node;
}

static JsonIsPredicate *
_readJsonIsPredicate(const OUT_TYPE(JsonIsPredicate, JsonIsPredicate) msg)
{
  JsonIsPredicate *node = makeNode(JsonIsPredicate);
  READ_NODE_PTR_FIELD(JsonIsPredicate, expr, expr, expr);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonIsPredicate, JsonFormat, json_format, format, format, format);
  READ_ENUM_FIELD(JsonIsPredicate, JsonValueType, item_type, item_type, item_type);
  READ_BOOL_FIELD(JsonIsPredicate, unique_keys, unique_keys, unique_keys);
  READ_INT_FIELD(JsonIsPredicate, location, location, location);
  return node;
}

static JsonBehavior *
_readJsonBehavior(const OUT_TYPE(JsonBehavior, JsonBehavior) msg)
{
  JsonBehavior *node = makeNode(JsonBehavior);
  READ_ENUM_FIELD(JsonBehavior, JsonBehaviorType, btype, btype, btype);
  READ_NODE_PTR_FIELD(JsonBehavior, expr, expr, expr);
  READ_BOOL_FIELD(JsonBehavior, coerce, coerce, coerce);
  READ_INT_FIELD(JsonBehavior, location, location, location);
  return node;
}

static JsonExpr *
_readJsonExpr(const OUT_TYPE(JsonExpr, JsonExpr) msg)
{
  JsonExpr *node = makeNode(JsonExpr);
  READ_ENUM_FIELD(JsonExpr, JsonExprOp, op, op, op);
  READ_STRING_FIELD(JsonExpr, column_name, column_name, column_name);
  READ_NODE_PTR_FIELD(JsonExpr, formatted_expr, formatted_expr, formatted_expr);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonExpr, JsonFormat, json_format, format, format, format);
  READ_NODE_PTR_FIELD(JsonExpr, path_spec, path_spec, path_spec);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonExpr, JsonReturning, json_returning, returning, returning, returning);
  READ_LIST_FIELD(JsonExpr, passing_names, passing_names, passing_names);
  READ_LIST_FIELD(JsonExpr, passing_values, passing_values, passing_values);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonExpr, JsonBehavior, json_behavior, on_empty, on_empty, on_empty);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonExpr, JsonBehavior, json_behavior, on_error, on_error, on_error);
  READ_BOOL_FIELD(JsonExpr, use_io_coercion, use_io_coercion, use_io_coercion);
  READ_BOOL_FIELD(JsonExpr, use_json_coercion, use_json_coercion, use_json_coercion);
  READ_ENUM_FIELD(JsonExpr, JsonWrapper, wrapper, wrapper, wrapper);
  READ_BOOL_FIELD(JsonExpr, omit_quotes, omit_quotes, omit_quotes);
  READ_UINT_FIELD(JsonExpr, collation, collation, collation);
  READ_INT_FIELD(JsonExpr, location, location, location);
  return node;
}

static JsonTablePath *
_readJsonTablePath(const OUT_TYPE(JsonTablePath, JsonTablePath) msg)
{
  JsonTablePath *node = makeNode(JsonTablePath);
  READ_STRING_FIELD(JsonTablePath, name, name, name);
  return node;
}

static JsonTablePathScan *
_readJsonTablePathScan(const OUT_TYPE(JsonTablePathScan, JsonTablePathScan) msg)
{
  JsonTablePathScan *node = makeNode(JsonTablePathScan);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonTablePathScan, JsonTablePath, json_table_path, path, path, path);
  READ_BOOL_FIELD(JsonTablePathScan, error_on_error, errorOnError, errorOnError);
  READ_ABSTRACT_PTR_FIELD(JsonTablePathScan, child, child, child, JsonTablePlan*);
  READ_INT_FIELD(JsonTablePathScan, col_min, colMin, colMin);
  READ_INT_FIELD(JsonTablePathScan, col_max, colMax, colMax);
  return node;
}

static JsonTableSiblingJoin *
_readJsonTableSiblingJoin(const OUT_TYPE(JsonTableSiblingJoin, JsonTableSiblingJoin) msg)
{
  JsonTableSiblingJoin *node = makeNode(JsonTableSiblingJoin);
  READ_ABSTRACT_PTR_FIELD(JsonTableSiblingJoin, lplan, lplan, lplan, JsonTablePlan*);
  READ_ABSTRACT_PTR_FIELD(JsonTableSiblingJoin, rplan, rplan, rplan, JsonTablePlan*);
  return node;
}

static NullTest *
_readNullTest(const OUT_TYPE(NullTest, NullTest) msg)
{
  NullTest *node = makeNode(NullTest);
  READ_ABSTRACT_PTR_FIELD(NullTest, arg, arg, arg, Expr*);
  READ_ENUM_FIELD(NullTest, NullTestType, nulltesttype, nulltesttype, nulltesttype);
  READ_BOOL_FIELD(NullTest, argisrow, argisrow, argisrow);
  READ_INT_FIELD(NullTest, location, location, location);
  return node;
}

static BooleanTest *
_readBooleanTest(const OUT_TYPE(BooleanTest, BooleanTest) msg)
{
  BooleanTest *node = makeNode(BooleanTest);
  READ_ABSTRACT_PTR_FIELD(BooleanTest, arg, arg, arg, Expr*);
  READ_ENUM_FIELD(BooleanTest, BoolTestType, booltesttype, booltesttype, booltesttype);
  READ_INT_FIELD(BooleanTest, location, location, location);
  return node;
}

static MergeAction *
_readMergeAction(const OUT_TYPE(MergeAction, MergeAction) msg)
{
  MergeAction *node = makeNode(MergeAction);
  READ_ENUM_FIELD(MergeAction, MergeMatchKind, match_kind, matchKind, matchKind);
  READ_ENUM_FIELD(MergeAction, CmdType, command_type, commandType, commandType);
  READ_ENUM_FIELD(MergeAction, OverridingKind, override, override, override);
  READ_NODE_PTR_FIELD(MergeAction, qual, qual, qual);
  READ_LIST_FIELD(MergeAction, target_list, targetList, targetList);
  READ_LIST_FIELD(MergeAction, update_colnos, updateColnos, updateColnos);
  return node;
}

static CoerceToDomain *
_readCoerceToDomain(const OUT_TYPE(CoerceToDomain, CoerceToDomain) msg)
{
  CoerceToDomain *node = makeNode(CoerceToDomain);
  READ_ABSTRACT_PTR_FIELD(CoerceToDomain, arg, arg, arg, Expr*);
  READ_UINT_FIELD(CoerceToDomain, resulttype, resulttype, resulttype);
  READ_INT_FIELD(CoerceToDomain, resulttypmod, resulttypmod, resulttypmod);
  READ_UINT_FIELD(CoerceToDomain, resultcollid, resultcollid, resultcollid);
  READ_ENUM_FIELD(CoerceToDomain, CoercionForm, coercionformat, coercionformat, coercionformat);
  READ_INT_FIELD(CoerceToDomain, location, location, location);
  return node;
}

static CoerceToDomainValue *
_readCoerceToDomainValue(const OUT_TYPE(CoerceToDomainValue, CoerceToDomainValue) msg)
{
  CoerceToDomainValue *node = makeNode(CoerceToDomainValue);
  READ_UINT_FIELD(CoerceToDomainValue, type_id, typeId, typeId);
  READ_INT_FIELD(CoerceToDomainValue, type_mod, typeMod, typeMod);
  READ_UINT_FIELD(CoerceToDomainValue, collation, collation, collation);
  READ_INT_FIELD(CoerceToDomainValue, location, location, location);
  return node;
}

static SetToDefault *
_readSetToDefault(const OUT_TYPE(SetToDefault, SetToDefault) msg)
{
  SetToDefault *node = makeNode(SetToDefault);
  READ_UINT_FIELD(SetToDefault, type_id, typeId, typeId);
  READ_INT_FIELD(SetToDefault, type_mod, typeMod, typeMod);
  READ_UINT_FIELD(SetToDefault, collation, collation, collation);
  READ_INT_FIELD(SetToDefault, location, location, location);
  return node;
}

static CurrentOfExpr *
_readCurrentOfExpr(const OUT_TYPE(CurrentOfExpr, CurrentOfExpr) msg)
{
  CurrentOfExpr *node = makeNode(CurrentOfExpr);
  READ_UINT_FIELD(CurrentOfExpr, cvarno, cvarno, cvarno);
  READ_STRING_FIELD(CurrentOfExpr, cursor_name, cursor_name, cursor_name);
  READ_INT_FIELD(CurrentOfExpr, cursor_param, cursor_param, cursor_param);
  return node;
}

static NextValueExpr *
_readNextValueExpr(const OUT_TYPE(NextValueExpr, NextValueExpr) msg)
{
  NextValueExpr *node = makeNode(NextValueExpr);
  READ_UINT_FIELD(NextValueExpr, seqid, seqid, seqid);
  READ_UINT_FIELD(NextValueExpr, type_id, typeId, typeId);
  return node;
}

static InferenceElem *
_readInferenceElem(const OUT_TYPE(InferenceElem, InferenceElem) msg)
{
  InferenceElem *node = makeNode(InferenceElem);
  READ_NODE_PTR_FIELD(InferenceElem, expr, expr, expr);
  READ_UINT_FIELD(InferenceElem, infercollid, infercollid, infercollid);
  READ_UINT_FIELD(InferenceElem, inferopclass, inferopclass, inferopclass);
  return node;
}

static ReturningExpr *
_readReturningExpr(const OUT_TYPE(ReturningExpr, ReturningExpr) msg)
{
  ReturningExpr *node = makeNode(ReturningExpr);
  READ_INT_FIELD(ReturningExpr, retlevelsup, retlevelsup, retlevelsup);
  READ_BOOL_FIELD(ReturningExpr, retold, retold, retold);
  READ_ABSTRACT_PTR_FIELD(ReturningExpr, retexpr, retexpr, retexpr, Expr*);
  return node;
}

static TargetEntry *
_readTargetEntry(const OUT_TYPE(TargetEntry, TargetEntry) msg)
{
  TargetEntry *node = makeNode(TargetEntry);
  READ_ABSTRACT_PTR_FIELD(TargetEntry, expr, expr, expr, Expr*);
  READ_INT_FIELD(TargetEntry, resno, resno, resno);
  READ_STRING_FIELD(TargetEntry, resname, resname, resname);
  READ_UINT_FIELD(TargetEntry, ressortgroupref, ressortgroupref, ressortgroupref);
  READ_UINT_FIELD(TargetEntry, resorigtbl, resorigtbl, resorigtbl);
  READ_INT_FIELD(TargetEntry, resorigcol, resorigcol, resorigcol);
  READ_BOOL_FIELD(TargetEntry, resjunk, resjunk, resjunk);
  return node;
}

static RangeTblRef *
_readRangeTblRef(const OUT_TYPE(RangeTblRef, RangeTblRef) msg)
{
  RangeTblRef *node = makeNode(RangeTblRef);
  READ_INT_FIELD(RangeTblRef, rtindex, rtindex, rtindex);
  return node;
}

static JoinExpr *
_readJoinExpr(const OUT_TYPE(JoinExpr, JoinExpr) msg)
{
  JoinExpr *node = makeNode(JoinExpr);
  READ_ENUM_FIELD(JoinExpr, JoinType, jointype, jointype, jointype);
  READ_BOOL_FIELD(JoinExpr, is_natural, isNatural, isNatural);
  READ_NODE_PTR_FIELD(JoinExpr, larg, larg, larg);
  READ_NODE_PTR_FIELD(JoinExpr, rarg, rarg, rarg);
  READ_LIST_FIELD(JoinExpr, using_clause, usingClause, usingClause);
  READ_SPECIFIC_NODE_PTR_FIELD(JoinExpr, Alias, alias, join_using_alias, join_using_alias, join_using_alias);
  READ_NODE_PTR_FIELD(JoinExpr, quals, quals, quals);
  READ_SPECIFIC_NODE_PTR_FIELD(JoinExpr, Alias, alias, alias, alias, alias);
  READ_INT_FIELD(JoinExpr, rtindex, rtindex, rtindex);
  return node;
}

static FromExpr *
_readFromExpr(const OUT_TYPE(FromExpr, FromExpr) msg)
{
  FromExpr *node = makeNode(FromExpr);
  READ_LIST_FIELD(FromExpr, fromlist, fromlist, fromlist);
  READ_NODE_PTR_FIELD(FromExpr, quals, quals, quals);
  return node;
}

static OnConflictExpr *
_readOnConflictExpr(const OUT_TYPE(OnConflictExpr, OnConflictExpr) msg)
{
  OnConflictExpr *node = makeNode(OnConflictExpr);
  READ_ENUM_FIELD(OnConflictExpr, OnConflictAction, action, action, action);
  READ_LIST_FIELD(OnConflictExpr, arbiter_elems, arbiterElems, arbiterElems);
  READ_NODE_PTR_FIELD(OnConflictExpr, arbiter_where, arbiterWhere, arbiterWhere);
  READ_UINT_FIELD(OnConflictExpr, constraint, constraint, constraint);
  READ_LIST_FIELD(OnConflictExpr, on_conflict_set, onConflictSet, onConflictSet);
  READ_NODE_PTR_FIELD(OnConflictExpr, on_conflict_where, onConflictWhere, onConflictWhere);
  READ_INT_FIELD(OnConflictExpr, excl_rel_index, exclRelIndex, exclRelIndex);
  READ_LIST_FIELD(OnConflictExpr, excl_rel_tlist, exclRelTlist, exclRelTlist);
  return node;
}

static Query *
_readQuery(const OUT_TYPE(Query, Query) msg)
{
  Query *node = makeNode(Query);
  READ_ENUM_FIELD(Query, CmdType, command_type, commandType, commandType);
  READ_ENUM_FIELD(Query, QuerySource, query_source, querySource, querySource);
  READ_BOOL_FIELD(Query, can_set_tag, canSetTag, canSetTag);
  READ_NODE_PTR_FIELD(Query, utility_stmt, utilityStmt, utilityStmt);
  READ_INT_FIELD(Query, result_relation, resultRelation, resultRelation);
  READ_BOOL_FIELD(Query, has_aggs, hasAggs, hasAggs);
  READ_BOOL_FIELD(Query, has_window_funcs, hasWindowFuncs, hasWindowFuncs);
  READ_BOOL_FIELD(Query, has_target_srfs, hasTargetSRFs, hasTargetSRFs);
  READ_BOOL_FIELD(Query, has_sub_links, hasSubLinks, hasSubLinks);
  READ_BOOL_FIELD(Query, has_distinct_on, hasDistinctOn, hasDistinctOn);
  READ_BOOL_FIELD(Query, has_recursive, hasRecursive, hasRecursive);
  READ_BOOL_FIELD(Query, has_modifying_cte, hasModifyingCTE, hasModifyingCTE);
  READ_BOOL_FIELD(Query, has_for_update, hasForUpdate, hasForUpdate);
  READ_BOOL_FIELD(Query, has_row_security, hasRowSecurity, hasRowSecurity);
  READ_BOOL_FIELD(Query, has_group_rte, hasGroupRTE, hasGroupRTE);
  READ_BOOL_FIELD(Query, is_return, isReturn, isReturn);
  READ_LIST_FIELD(Query, cte_list, cteList, cteList);
  READ_LIST_FIELD(Query, rtable, rtable, rtable);
  READ_LIST_FIELD(Query, rteperminfos, rteperminfos, rteperminfos);
  READ_SPECIFIC_NODE_PTR_FIELD(Query, FromExpr, from_expr, jointree, jointree, jointree);
  READ_LIST_FIELD(Query, merge_action_list, mergeActionList, mergeActionList);
  READ_INT_FIELD(Query, merge_target_relation, mergeTargetRelation, mergeTargetRelation);
  READ_NODE_PTR_FIELD(Query, merge_join_condition, mergeJoinCondition, mergeJoinCondition);
  READ_LIST_FIELD(Query, target_list, targetList, targetList);
  READ_ENUM_FIELD(Query, OverridingKind, override, override, override);
  READ_SPECIFIC_NODE_PTR_FIELD(Query, OnConflictExpr, on_conflict_expr, on_conflict, onConflict, onConflict);
  READ_STRING_FIELD(Query, returning_old_alias, returningOldAlias, returningOldAlias);
  READ_STRING_FIELD(Query, returning_new_alias, returningNewAlias, returningNewAlias);
  READ_LIST_FIELD(Query, returning_list, returningList, returningList);
  READ_LIST_FIELD(Query, group_clause, groupClause, groupClause);
  READ_BOOL_FIELD(Query, group_distinct, groupDistinct, groupDistinct);
  READ_LIST_FIELD(Query, grouping_sets, groupingSets, groupingSets);
  READ_NODE_PTR_FIELD(Query, having_qual, havingQual, havingQual);
  READ_LIST_FIELD(Query, window_clause, windowClause, windowClause);
  READ_LIST_FIELD(Query, distinct_clause, distinctClause, distinctClause);
  READ_LIST_FIELD(Query, sort_clause, sortClause, sortClause);
  READ_NODE_PTR_FIELD(Query, limit_offset, limitOffset, limitOffset);
  READ_NODE_PTR_FIELD(Query, limit_count, limitCount, limitCount);
  READ_ENUM_FIELD(Query, LimitOption, limit_option, limitOption, limitOption);
  READ_LIST_FIELD(Query, row_marks, rowMarks, rowMarks);
  READ_NODE_PTR_FIELD(Query, set_operations, setOperations, setOperations);
  READ_LIST_FIELD(Query, constraint_deps, constraintDeps, constraintDeps);
  READ_LIST_FIELD(Query, with_check_options, withCheckOptions, withCheckOptions);
  READ_INT_FIELD(Query, stmt_location, stmt_location, stmt_location);
  READ_INT_FIELD(Query, stmt_len, stmt_len, stmt_len);
  return node;
}

static TypeName *
_readTypeName(const OUT_TYPE(TypeName, TypeName) msg)
{
  TypeName *node = makeNode(TypeName);
  READ_LIST_FIELD(TypeName, names, names, names);
  READ_UINT_FIELD(TypeName, type_oid, typeOid, typeOid);
  READ_BOOL_FIELD(TypeName, setof, setof, setof);
  READ_BOOL_FIELD(TypeName, pct_type, pct_type, pct_type);
  READ_LIST_FIELD(TypeName, typmods, typmods, typmods);
  READ_INT_FIELD(TypeName, typemod, typemod, typemod);
  READ_LIST_FIELD(TypeName, array_bounds, arrayBounds, arrayBounds);
  READ_INT_FIELD(TypeName, location, location, location);
  return node;
}

static ColumnRef *
_readColumnRef(const OUT_TYPE(ColumnRef, ColumnRef) msg)
{
  ColumnRef *node = makeNode(ColumnRef);
  READ_LIST_FIELD(ColumnRef, fields, fields, fields);
  READ_INT_FIELD(ColumnRef, location, location, location);
  return node;
}

static ParamRef *
_readParamRef(const OUT_TYPE(ParamRef, ParamRef) msg)
{
  ParamRef *node = makeNode(ParamRef);
  READ_INT_FIELD(ParamRef, number, number, number);
  READ_INT_FIELD(ParamRef, location, location, location);
  return node;
}

static A_Expr *
_readAExpr(const OUT_TYPE(A_Expr, AExpr) msg)
{
  A_Expr *node = makeNode(A_Expr);
  READ_ENUM_FIELD(A_Expr, A_Expr_Kind, kind, kind, kind);
  READ_LIST_FIELD(A_Expr, name, name, name);
  READ_NODE_PTR_FIELD(A_Expr, lexpr, lexpr, lexpr);
  READ_NODE_PTR_FIELD(A_Expr, rexpr, rexpr, rexpr);
  READ_INT_FIELD(A_Expr, rexpr_list_start, rexpr_list_start, rexpr_list_start);
  READ_INT_FIELD(A_Expr, rexpr_list_end, rexpr_list_end, rexpr_list_end);
  READ_INT_FIELD(A_Expr, location, location, location);
  return node;
}

static TypeCast *
_readTypeCast(const OUT_TYPE(TypeCast, TypeCast) msg)
{
  TypeCast *node = makeNode(TypeCast);
  READ_NODE_PTR_FIELD(TypeCast, arg, arg, arg);
  READ_SPECIFIC_NODE_PTR_FIELD(TypeCast, TypeName, type_name, type_name, typeName, typeName);
  READ_INT_FIELD(TypeCast, location, location, location);
  return node;
}

static CollateClause *
_readCollateClause(const OUT_TYPE(CollateClause, CollateClause) msg)
{
  CollateClause *node = makeNode(CollateClause);
  READ_NODE_PTR_FIELD(CollateClause, arg, arg, arg);
  READ_LIST_FIELD(CollateClause, collname, collname, collname);
  READ_INT_FIELD(CollateClause, location, location, location);
  return node;
}

static RoleSpec *
_readRoleSpec(const OUT_TYPE(RoleSpec, RoleSpec) msg)
{
  RoleSpec *node = makeNode(RoleSpec);
  READ_ENUM_FIELD(RoleSpec, RoleSpecType, roletype, roletype, roletype);
  READ_STRING_FIELD(RoleSpec, rolename, rolename, rolename);
  READ_INT_FIELD(RoleSpec, location, location, location);
  return node;
}

static FuncCall *
_readFuncCall(const OUT_TYPE(FuncCall, FuncCall) msg)
{
  FuncCall *node = makeNode(FuncCall);
  READ_LIST_FIELD(FuncCall, funcname, funcname, funcname);
  READ_LIST_FIELD(FuncCall, args, args, args);
  READ_LIST_FIELD(FuncCall, agg_order, agg_order, agg_order);
  READ_NODE_PTR_FIELD(FuncCall, agg_filter, agg_filter, agg_filter);
  READ_SPECIFIC_NODE_PTR_FIELD(FuncCall, WindowDef, window_def, over, over, over);
  READ_BOOL_FIELD(FuncCall, agg_within_group, agg_within_group, agg_within_group);
  READ_BOOL_FIELD(FuncCall, agg_star, agg_star, agg_star);
  READ_BOOL_FIELD(FuncCall, agg_distinct, agg_distinct, agg_distinct);
  READ_BOOL_FIELD(FuncCall, func_variadic, func_variadic, func_variadic);
  READ_ENUM_FIELD(FuncCall, CoercionForm, funcformat, funcformat, funcformat);
  READ_INT_FIELD(FuncCall, location, location, location);
  return node;
}

static A_Star *
_readAStar(const OUT_TYPE(A_Star, AStar) msg)
{
  A_Star *node = makeNode(A_Star);
  return node;
}

static A_Indices *
_readAIndices(const OUT_TYPE(A_Indices, AIndices) msg)
{
  A_Indices *node = makeNode(A_Indices);
  READ_BOOL_FIELD(A_Indices, is_slice, is_slice, is_slice);
  READ_NODE_PTR_FIELD(A_Indices, lidx, lidx, lidx);
  READ_NODE_PTR_FIELD(A_Indices, uidx, uidx, uidx);
  return node;
}

static A_Indirection *
_readAIndirection(const OUT_TYPE(A_Indirection, AIndirection) msg)
{
  A_Indirection *node = makeNode(A_Indirection);
  READ_NODE_PTR_FIELD(A_Indirection, arg, arg, arg);
  READ_LIST_FIELD(A_Indirection, indirection, indirection, indirection);
  return node;
}

static A_ArrayExpr *
_readAArrayExpr(const OUT_TYPE(A_ArrayExpr, AArrayExpr) msg)
{
  A_ArrayExpr *node = makeNode(A_ArrayExpr);
  READ_LIST_FIELD(A_ArrayExpr, elements, elements, elements);
  READ_INT_FIELD(A_ArrayExpr, list_start, list_start, list_start);
  READ_INT_FIELD(A_ArrayExpr, list_end, list_end, list_end);
  READ_INT_FIELD(A_ArrayExpr, location, location, location);
  return node;
}

static ResTarget *
_readResTarget(const OUT_TYPE(ResTarget, ResTarget) msg)
{
  ResTarget *node = makeNode(ResTarget);
  READ_STRING_FIELD(ResTarget, name, name, name);
  READ_LIST_FIELD(ResTarget, indirection, indirection, indirection);
  READ_NODE_PTR_FIELD(ResTarget, val, val, val);
  READ_INT_FIELD(ResTarget, location, location, location);
  return node;
}

static MultiAssignRef *
_readMultiAssignRef(const OUT_TYPE(MultiAssignRef, MultiAssignRef) msg)
{
  MultiAssignRef *node = makeNode(MultiAssignRef);
  READ_NODE_PTR_FIELD(MultiAssignRef, source, source, source);
  READ_INT_FIELD(MultiAssignRef, colno, colno, colno);
  READ_INT_FIELD(MultiAssignRef, ncolumns, ncolumns, ncolumns);
  return node;
}

static SortBy *
_readSortBy(const OUT_TYPE(SortBy, SortBy) msg)
{
  SortBy *node = makeNode(SortBy);
  READ_NODE_PTR_FIELD(SortBy, node, node, node);
  READ_ENUM_FIELD(SortBy, SortByDir, sortby_dir, sortby_dir, sortby_dir);
  READ_ENUM_FIELD(SortBy, SortByNulls, sortby_nulls, sortby_nulls, sortby_nulls);
  READ_LIST_FIELD(SortBy, use_op, useOp, useOp);
  READ_INT_FIELD(SortBy, location, location, location);
  return node;
}

static WindowDef *
_readWindowDef(const OUT_TYPE(WindowDef, WindowDef) msg)
{
  WindowDef *node = makeNode(WindowDef);
  READ_STRING_FIELD(WindowDef, name, name, name);
  READ_STRING_FIELD(WindowDef, refname, refname, refname);
  READ_LIST_FIELD(WindowDef, partition_clause, partitionClause, partitionClause);
  READ_LIST_FIELD(WindowDef, order_clause, orderClause, orderClause);
  READ_INT_FIELD(WindowDef, frame_options, frameOptions, frameOptions);
  READ_NODE_PTR_FIELD(WindowDef, start_offset, startOffset, startOffset);
  READ_NODE_PTR_FIELD(WindowDef, end_offset, endOffset, endOffset);
  READ_INT_FIELD(WindowDef, location, location, location);
  return node;
}

static RangeSubselect *
_readRangeSubselect(const OUT_TYPE(RangeSubselect, RangeSubselect) msg)
{
  RangeSubselect *node = makeNode(RangeSubselect);
  READ_BOOL_FIELD(RangeSubselect, lateral, lateral, lateral);
  READ_NODE_PTR_FIELD(RangeSubselect, subquery, subquery, subquery);
  READ_SPECIFIC_NODE_PTR_FIELD(RangeSubselect, Alias, alias, alias, alias, alias);
  return node;
}

static RangeFunction *
_readRangeFunction(const OUT_TYPE(RangeFunction, RangeFunction) msg)
{
  RangeFunction *node = makeNode(RangeFunction);
  READ_BOOL_FIELD(RangeFunction, lateral, lateral, lateral);
  READ_BOOL_FIELD(RangeFunction, ordinality, ordinality, ordinality);
  READ_BOOL_FIELD(RangeFunction, is_rowsfrom, is_rowsfrom, is_rowsfrom);
  READ_LIST_FIELD(RangeFunction, functions, functions, functions);
  READ_SPECIFIC_NODE_PTR_FIELD(RangeFunction, Alias, alias, alias, alias, alias);
  READ_LIST_FIELD(RangeFunction, coldeflist, coldeflist, coldeflist);
  return node;
}

static RangeTableFunc *
_readRangeTableFunc(const OUT_TYPE(RangeTableFunc, RangeTableFunc) msg)
{
  RangeTableFunc *node = makeNode(RangeTableFunc);
  READ_BOOL_FIELD(RangeTableFunc, lateral, lateral, lateral);
  READ_NODE_PTR_FIELD(RangeTableFunc, docexpr, docexpr, docexpr);
  READ_NODE_PTR_FIELD(RangeTableFunc, rowexpr, rowexpr, rowexpr);
  READ_LIST_FIELD(RangeTableFunc, namespaces, namespaces, namespaces);
  READ_LIST_FIELD(RangeTableFunc, columns, columns, columns);
  READ_SPECIFIC_NODE_PTR_FIELD(RangeTableFunc, Alias, alias, alias, alias, alias);
  READ_INT_FIELD(RangeTableFunc, location, location, location);
  return node;
}

static RangeTableFuncCol *
_readRangeTableFuncCol(const OUT_TYPE(RangeTableFuncCol, RangeTableFuncCol) msg)
{
  RangeTableFuncCol *node = makeNode(RangeTableFuncCol);
  READ_STRING_FIELD(RangeTableFuncCol, colname, colname, colname);
  READ_SPECIFIC_NODE_PTR_FIELD(RangeTableFuncCol, TypeName, type_name, type_name, typeName, typeName);
  READ_BOOL_FIELD(RangeTableFuncCol, for_ordinality, for_ordinality, for_ordinality);
  READ_BOOL_FIELD(RangeTableFuncCol, is_not_null, is_not_null, is_not_null);
  READ_NODE_PTR_FIELD(RangeTableFuncCol, colexpr, colexpr, colexpr);
  READ_NODE_PTR_FIELD(RangeTableFuncCol, coldefexpr, coldefexpr, coldefexpr);
  READ_INT_FIELD(RangeTableFuncCol, location, location, location);
  return node;
}

static RangeTableSample *
_readRangeTableSample(const OUT_TYPE(RangeTableSample, RangeTableSample) msg)
{
  RangeTableSample *node = makeNode(RangeTableSample);
  READ_NODE_PTR_FIELD(RangeTableSample, relation, relation, relation);
  READ_LIST_FIELD(RangeTableSample, method, method, method);
  READ_LIST_FIELD(RangeTableSample, args, args, args);
  READ_NODE_PTR_FIELD(RangeTableSample, repeatable, repeatable, repeatable);
  READ_INT_FIELD(RangeTableSample, location, location, location);
  return node;
}

static ColumnDef *
_readColumnDef(const OUT_TYPE(ColumnDef, ColumnDef) msg)
{
  ColumnDef *node = makeNode(ColumnDef);
  READ_STRING_FIELD(ColumnDef, colname, colname, colname);
  READ_SPECIFIC_NODE_PTR_FIELD(ColumnDef, TypeName, type_name, type_name, typeName, typeName);
  READ_STRING_FIELD(ColumnDef, compression, compression, compression);
  READ_INT_FIELD(ColumnDef, inhcount, inhcount, inhcount);
  READ_BOOL_FIELD(ColumnDef, is_local, is_local, is_local);
  READ_BOOL_FIELD(ColumnDef, is_not_null, is_not_null, is_not_null);
  READ_BOOL_FIELD(ColumnDef, is_from_type, is_from_type, is_from_type);
  READ_CHAR_FIELD(ColumnDef, storage, storage, storage);
  READ_STRING_FIELD(ColumnDef, storage_name, storage_name, storage_name);
  READ_NODE_PTR_FIELD(ColumnDef, raw_default, raw_default, raw_default);
  READ_NODE_PTR_FIELD(ColumnDef, cooked_default, cooked_default, cooked_default);
  READ_CHAR_FIELD(ColumnDef, identity, identity, identity);
  READ_SPECIFIC_NODE_PTR_FIELD(ColumnDef, RangeVar, range_var, identity_sequence, identitySequence, identitySequence);
  READ_CHAR_FIELD(ColumnDef, generated, generated, generated);
  READ_SPECIFIC_NODE_PTR_FIELD(ColumnDef, CollateClause, collate_clause, coll_clause, collClause, collClause);
  READ_UINT_FIELD(ColumnDef, coll_oid, collOid, collOid);
  READ_LIST_FIELD(ColumnDef, constraints, constraints, constraints);
  READ_LIST_FIELD(ColumnDef, fdwoptions, fdwoptions, fdwoptions);
  READ_INT_FIELD(ColumnDef, location, location, location);
  return node;
}

static TableLikeClause *
_readTableLikeClause(const OUT_TYPE(TableLikeClause, TableLikeClause) msg)
{
  TableLikeClause *node = makeNode(TableLikeClause);
  READ_SPECIFIC_NODE_PTR_FIELD(TableLikeClause, RangeVar, range_var, relation, relation, relation);
  READ_UINT_FIELD(TableLikeClause, options, options, options);
  READ_UINT_FIELD(TableLikeClause, relation_oid, relationOid, relationOid);
  return node;
}

static IndexElem *
_readIndexElem(const OUT_TYPE(IndexElem, IndexElem) msg)
{
  IndexElem *node = makeNode(IndexElem);
  READ_STRING_FIELD(IndexElem, name, name, name);
  READ_NODE_PTR_FIELD(IndexElem, expr, expr, expr);
  READ_STRING_FIELD(IndexElem, indexcolname, indexcolname, indexcolname);
  READ_LIST_FIELD(IndexElem, collation, collation, collation);
  READ_LIST_FIELD(IndexElem, opclass, opclass, opclass);
  READ_LIST_FIELD(IndexElem, opclassopts, opclassopts, opclassopts);
  READ_ENUM_FIELD(IndexElem, SortByDir, ordering, ordering, ordering);
  READ_ENUM_FIELD(IndexElem, SortByNulls, nulls_ordering, nulls_ordering, nulls_ordering);
  return node;
}

static DefElem *
_readDefElem(const OUT_TYPE(DefElem, DefElem) msg)
{
  DefElem *node = makeNode(DefElem);
  READ_STRING_FIELD(DefElem, defnamespace, defnamespace, defnamespace);
  READ_STRING_FIELD(DefElem, defname, defname, defname);
  READ_NODE_PTR_FIELD(DefElem, arg, arg, arg);
  READ_ENUM_FIELD(DefElem, DefElemAction, defaction, defaction, defaction);
  READ_INT_FIELD(DefElem, location, location, location);
  READ_INT_FIELD(DefElem, arg_location, arg_location, arg_location);
  return node;
}

static LockingClause *
_readLockingClause(const OUT_TYPE(LockingClause, LockingClause) msg)
{
  LockingClause *node = makeNode(LockingClause);
  READ_LIST_FIELD(LockingClause, locked_rels, lockedRels, lockedRels);
  READ_ENUM_FIELD(LockingClause, LockClauseStrength, strength, strength, strength);
  READ_ENUM_FIELD(LockingClause, LockWaitPolicy, wait_policy, waitPolicy, waitPolicy);
  return node;
}

static XmlSerialize *
_readXmlSerialize(const OUT_TYPE(XmlSerialize, XmlSerialize) msg)
{
  XmlSerialize *node = makeNode(XmlSerialize);
  READ_ENUM_FIELD(XmlSerialize, XmlOptionType, xmloption, xmloption, xmloption);
  READ_NODE_PTR_FIELD(XmlSerialize, expr, expr, expr);
  READ_SPECIFIC_NODE_PTR_FIELD(XmlSerialize, TypeName, type_name, type_name, typeName, typeName);
  READ_BOOL_FIELD(XmlSerialize, indent, indent, indent);
  READ_INT_FIELD(XmlSerialize, location, location, location);
  return node;
}

static PartitionElem *
_readPartitionElem(const OUT_TYPE(PartitionElem, PartitionElem) msg)
{
  PartitionElem *node = makeNode(PartitionElem);
  READ_STRING_FIELD(PartitionElem, name, name, name);
  READ_NODE_PTR_FIELD(PartitionElem, expr, expr, expr);
  READ_LIST_FIELD(PartitionElem, collation, collation, collation);
  READ_LIST_FIELD(PartitionElem, opclass, opclass, opclass);
  READ_INT_FIELD(PartitionElem, location, location, location);
  return node;
}

static PartitionSpec *
_readPartitionSpec(const OUT_TYPE(PartitionSpec, PartitionSpec) msg)
{
  PartitionSpec *node = makeNode(PartitionSpec);
  READ_ENUM_FIELD(PartitionSpec, PartitionStrategy, strategy, strategy, strategy);
  READ_LIST_FIELD(PartitionSpec, part_params, partParams, partParams);
  READ_INT_FIELD(PartitionSpec, location, location, location);
  return node;
}

static PartitionBoundSpec *
_readPartitionBoundSpec(const OUT_TYPE(PartitionBoundSpec, PartitionBoundSpec) msg)
{
  PartitionBoundSpec *node = makeNode(PartitionBoundSpec);
  READ_CHAR_FIELD(PartitionBoundSpec, strategy, strategy, strategy);
  READ_BOOL_FIELD(PartitionBoundSpec, is_default, is_default, is_default);
  READ_INT_FIELD(PartitionBoundSpec, modulus, modulus, modulus);
  READ_INT_FIELD(PartitionBoundSpec, remainder, remainder, remainder);
  READ_LIST_FIELD(PartitionBoundSpec, listdatums, listdatums, listdatums);
  READ_LIST_FIELD(PartitionBoundSpec, lowerdatums, lowerdatums, lowerdatums);
  READ_LIST_FIELD(PartitionBoundSpec, upperdatums, upperdatums, upperdatums);
  READ_INT_FIELD(PartitionBoundSpec, location, location, location);
  return node;
}

static PartitionRangeDatum *
_readPartitionRangeDatum(const OUT_TYPE(PartitionRangeDatum, PartitionRangeDatum) msg)
{
  PartitionRangeDatum *node = makeNode(PartitionRangeDatum);
  READ_ENUM_FIELD(PartitionRangeDatum, PartitionRangeDatumKind, kind, kind, kind);
  READ_NODE_PTR_FIELD(PartitionRangeDatum, value, value, value);
  READ_INT_FIELD(PartitionRangeDatum, location, location, location);
  return node;
}

static PartitionCmd *
_readPartitionCmd(const OUT_TYPE(PartitionCmd, PartitionCmd) msg)
{
  PartitionCmd *node = makeNode(PartitionCmd);
  READ_SPECIFIC_NODE_PTR_FIELD(PartitionCmd, RangeVar, range_var, name, name, name);
  READ_SPECIFIC_NODE_PTR_FIELD(PartitionCmd, PartitionBoundSpec, partition_bound_spec, bound, bound, bound);
  READ_BOOL_FIELD(PartitionCmd, concurrent, concurrent, concurrent);
  return node;
}

static RangeTblEntry *
_readRangeTblEntry(const OUT_TYPE(RangeTblEntry, RangeTblEntry) msg)
{
  RangeTblEntry *node = makeNode(RangeTblEntry);
  READ_SPECIFIC_NODE_PTR_FIELD(RangeTblEntry, Alias, alias, alias, alias, alias);
  READ_SPECIFIC_NODE_PTR_FIELD(RangeTblEntry, Alias, alias, eref, eref, eref);
  READ_ENUM_FIELD(RangeTblEntry, RTEKind, rtekind, rtekind, rtekind);
  READ_UINT_FIELD(RangeTblEntry, relid, relid, relid);
  READ_BOOL_FIELD(RangeTblEntry, inh, inh, inh);
  READ_CHAR_FIELD(RangeTblEntry, relkind, relkind, relkind);
  READ_INT_FIELD(RangeTblEntry, rellockmode, rellockmode, rellockmode);
  READ_UINT_FIELD(RangeTblEntry, perminfoindex, perminfoindex, perminfoindex);
  READ_SPECIFIC_NODE_PTR_FIELD(RangeTblEntry, TableSampleClause, table_sample_clause, tablesample, tablesample, tablesample);
  READ_SPECIFIC_NODE_PTR_FIELD(RangeTblEntry, Query, query, subquery, subquery, subquery);
  READ_BOOL_FIELD(RangeTblEntry, security_barrier, security_barrier, security_barrier);
  READ_ENUM_FIELD(RangeTblEntry, JoinType, jointype, jointype, jointype);
  READ_INT_FIELD(RangeTblEntry, joinmergedcols, joinmergedcols, joinmergedcols);
  READ_LIST_FIELD(RangeTblEntry, joinaliasvars, joinaliasvars, joinaliasvars);
  READ_LIST_FIELD(RangeTblEntry, joinleftcols, joinleftcols, joinleftcols);
  READ_LIST_FIELD(RangeTblEntry, joinrightcols, joinrightcols, joinrightcols);
  READ_SPECIFIC_NODE_PTR_FIELD(RangeTblEntry, Alias, alias, join_using_alias, join_using_alias, join_using_alias);
  READ_LIST_FIELD(RangeTblEntry, functions, functions, functions);
  READ_BOOL_FIELD(RangeTblEntry, funcordinality, funcordinality, funcordinality);
  READ_SPECIFIC_NODE_PTR_FIELD(RangeTblEntry, TableFunc, table_func, tablefunc, tablefunc, tablefunc);
  READ_LIST_FIELD(RangeTblEntry, values_lists, values_lists, values_lists);
  READ_STRING_FIELD(RangeTblEntry, ctename, ctename, ctename);
  READ_UINT_FIELD(RangeTblEntry, ctelevelsup, ctelevelsup, ctelevelsup);
  READ_BOOL_FIELD(RangeTblEntry, self_reference, self_reference, self_reference);
  READ_LIST_FIELD(RangeTblEntry, coltypes, coltypes, coltypes);
  READ_LIST_FIELD(RangeTblEntry, coltypmods, coltypmods, coltypmods);
  READ_LIST_FIELD(RangeTblEntry, colcollations, colcollations, colcollations);
  READ_STRING_FIELD(RangeTblEntry, enrname, enrname, enrname);
  READ_FLOAT_FIELD(RangeTblEntry, enrtuples, enrtuples, enrtuples);
  READ_LIST_FIELD(RangeTblEntry, groupexprs, groupexprs, groupexprs);
  READ_BOOL_FIELD(RangeTblEntry, lateral, lateral, lateral);
  READ_BOOL_FIELD(RangeTblEntry, in_from_cl, inFromCl, inFromCl);
  READ_LIST_FIELD(RangeTblEntry, security_quals, securityQuals, securityQuals);
  return node;
}

static RTEPermissionInfo *
_readRTEPermissionInfo(const OUT_TYPE(RTEPermissionInfo, RTEPermissionInfo) msg)
{
  RTEPermissionInfo *node = makeNode(RTEPermissionInfo);
  READ_UINT_FIELD(RTEPermissionInfo, relid, relid, relid);
  READ_BOOL_FIELD(RTEPermissionInfo, inh, inh, inh);
  READ_UINT64_FIELD(RTEPermissionInfo, required_perms, requiredPerms, requiredPerms);
  READ_UINT_FIELD(RTEPermissionInfo, check_as_user, checkAsUser, checkAsUser);
  READ_BITMAPSET_FIELD(RTEPermissionInfo, selected_cols, selectedCols, selectedCols);
  READ_BITMAPSET_FIELD(RTEPermissionInfo, inserted_cols, insertedCols, insertedCols);
  READ_BITMAPSET_FIELD(RTEPermissionInfo, updated_cols, updatedCols, updatedCols);
  return node;
}

static RangeTblFunction *
_readRangeTblFunction(const OUT_TYPE(RangeTblFunction, RangeTblFunction) msg)
{
  RangeTblFunction *node = makeNode(RangeTblFunction);
  READ_NODE_PTR_FIELD(RangeTblFunction, funcexpr, funcexpr, funcexpr);
  READ_INT_FIELD(RangeTblFunction, funccolcount, funccolcount, funccolcount);
  READ_LIST_FIELD(RangeTblFunction, funccolnames, funccolnames, funccolnames);
  READ_LIST_FIELD(RangeTblFunction, funccoltypes, funccoltypes, funccoltypes);
  READ_LIST_FIELD(RangeTblFunction, funccoltypmods, funccoltypmods, funccoltypmods);
  READ_LIST_FIELD(RangeTblFunction, funccolcollations, funccolcollations, funccolcollations);
  READ_BITMAPSET_FIELD(RangeTblFunction, funcparams, funcparams, funcparams);
  return node;
}

static TableSampleClause *
_readTableSampleClause(const OUT_TYPE(TableSampleClause, TableSampleClause) msg)
{
  TableSampleClause *node = makeNode(TableSampleClause);
  READ_UINT_FIELD(TableSampleClause, tsmhandler, tsmhandler, tsmhandler);
  READ_LIST_FIELD(TableSampleClause, args, args, args);
  READ_ABSTRACT_PTR_FIELD(TableSampleClause, repeatable, repeatable, repeatable, Expr*);
  return node;
}

static WithCheckOption *
_readWithCheckOption(const OUT_TYPE(WithCheckOption, WithCheckOption) msg)
{
  WithCheckOption *node = makeNode(WithCheckOption);
  READ_ENUM_FIELD(WithCheckOption, WCOKind, kind, kind, kind);
  READ_STRING_FIELD(WithCheckOption, relname, relname, relname);
  READ_STRING_FIELD(WithCheckOption, polname, polname, polname);
  READ_NODE_PTR_FIELD(WithCheckOption, qual, qual, qual);
  READ_BOOL_FIELD(WithCheckOption, cascaded, cascaded, cascaded);
  return node;
}

static SortGroupClause *
_readSortGroupClause(const OUT_TYPE(SortGroupClause, SortGroupClause) msg)
{
  SortGroupClause *node = makeNode(SortGroupClause);
  READ_UINT_FIELD(SortGroupClause, tle_sort_group_ref, tleSortGroupRef, tleSortGroupRef);
  READ_UINT_FIELD(SortGroupClause, eqop, eqop, eqop);
  READ_UINT_FIELD(SortGroupClause, sortop, sortop, sortop);
  READ_BOOL_FIELD(SortGroupClause, reverse_sort, reverse_sort, reverse_sort);
  READ_BOOL_FIELD(SortGroupClause, nulls_first, nulls_first, nulls_first);
  READ_BOOL_FIELD(SortGroupClause, hashable, hashable, hashable);
  return node;
}

static GroupingSet *
_readGroupingSet(const OUT_TYPE(GroupingSet, GroupingSet) msg)
{
  GroupingSet *node = makeNode(GroupingSet);
  READ_ENUM_FIELD(GroupingSet, GroupingSetKind, kind, kind, kind);
  READ_LIST_FIELD(GroupingSet, content, content, content);
  READ_INT_FIELD(GroupingSet, location, location, location);
  return node;
}

static WindowClause *
_readWindowClause(const OUT_TYPE(WindowClause, WindowClause) msg)
{
  WindowClause *node = makeNode(WindowClause);
  READ_STRING_FIELD(WindowClause, name, name, name);
  READ_STRING_FIELD(WindowClause, refname, refname, refname);
  READ_LIST_FIELD(WindowClause, partition_clause, partitionClause, partitionClause);
  READ_LIST_FIELD(WindowClause, order_clause, orderClause, orderClause);
  READ_INT_FIELD(WindowClause, frame_options, frameOptions, frameOptions);
  READ_NODE_PTR_FIELD(WindowClause, start_offset, startOffset, startOffset);
  READ_NODE_PTR_FIELD(WindowClause, end_offset, endOffset, endOffset);
  READ_UINT_FIELD(WindowClause, start_in_range_func, startInRangeFunc, startInRangeFunc);
  READ_UINT_FIELD(WindowClause, end_in_range_func, endInRangeFunc, endInRangeFunc);
  READ_UINT_FIELD(WindowClause, in_range_coll, inRangeColl, inRangeColl);
  READ_BOOL_FIELD(WindowClause, in_range_asc, inRangeAsc, inRangeAsc);
  READ_BOOL_FIELD(WindowClause, in_range_nulls_first, inRangeNullsFirst, inRangeNullsFirst);
  READ_UINT_FIELD(WindowClause, winref, winref, winref);
  READ_BOOL_FIELD(WindowClause, copied_order, copiedOrder, copiedOrder);
  return node;
}

static RowMarkClause *
_readRowMarkClause(const OUT_TYPE(RowMarkClause, RowMarkClause) msg)
{
  RowMarkClause *node = makeNode(RowMarkClause);
  READ_UINT_FIELD(RowMarkClause, rti, rti, rti);
  READ_ENUM_FIELD(RowMarkClause, LockClauseStrength, strength, strength, strength);
  READ_ENUM_FIELD(RowMarkClause, LockWaitPolicy, wait_policy, waitPolicy, waitPolicy);
  READ_BOOL_FIELD(RowMarkClause, pushed_down, pushedDown, pushedDown);
  return node;
}

static WithClause *
_readWithClause(const OUT_TYPE(WithClause, WithClause) msg)
{
  WithClause *node = makeNode(WithClause);
  READ_LIST_FIELD(WithClause, ctes, ctes, ctes);
  READ_BOOL_FIELD(WithClause, recursive, recursive, recursive);
  READ_INT_FIELD(WithClause, location, location, location);
  return node;
}

static InferClause *
_readInferClause(const OUT_TYPE(InferClause, InferClause) msg)
{
  InferClause *node = makeNode(InferClause);
  READ_LIST_FIELD(InferClause, index_elems, indexElems, indexElems);
  READ_NODE_PTR_FIELD(InferClause, where_clause, whereClause, whereClause);
  READ_STRING_FIELD(InferClause, conname, conname, conname);
  READ_INT_FIELD(InferClause, location, location, location);
  return node;
}

static OnConflictClause *
_readOnConflictClause(const OUT_TYPE(OnConflictClause, OnConflictClause) msg)
{
  OnConflictClause *node = makeNode(OnConflictClause);
  READ_ENUM_FIELD(OnConflictClause, OnConflictAction, action, action, action);
  READ_SPECIFIC_NODE_PTR_FIELD(OnConflictClause, InferClause, infer_clause, infer, infer, infer);
  READ_LIST_FIELD(OnConflictClause, target_list, targetList, targetList);
  READ_NODE_PTR_FIELD(OnConflictClause, where_clause, whereClause, whereClause);
  READ_INT_FIELD(OnConflictClause, location, location, location);
  return node;
}

static CTESearchClause *
_readCTESearchClause(const OUT_TYPE(CTESearchClause, CTESearchClause) msg)
{
  CTESearchClause *node = makeNode(CTESearchClause);
  READ_LIST_FIELD(CTESearchClause, search_col_list, search_col_list, search_col_list);
  READ_BOOL_FIELD(CTESearchClause, search_breadth_first, search_breadth_first, search_breadth_first);
  READ_STRING_FIELD(CTESearchClause, search_seq_column, search_seq_column, search_seq_column);
  READ_INT_FIELD(CTESearchClause, location, location, location);
  return node;
}

static CTECycleClause *
_readCTECycleClause(const OUT_TYPE(CTECycleClause, CTECycleClause) msg)
{
  CTECycleClause *node = makeNode(CTECycleClause);
  READ_LIST_FIELD(CTECycleClause, cycle_col_list, cycle_col_list, cycle_col_list);
  READ_STRING_FIELD(CTECycleClause, cycle_mark_column, cycle_mark_column, cycle_mark_column);
  READ_NODE_PTR_FIELD(CTECycleClause, cycle_mark_value, cycle_mark_value, cycle_mark_value);
  READ_NODE_PTR_FIELD(CTECycleClause, cycle_mark_default, cycle_mark_default, cycle_mark_default);
  READ_STRING_FIELD(CTECycleClause, cycle_path_column, cycle_path_column, cycle_path_column);
  READ_INT_FIELD(CTECycleClause, location, location, location);
  READ_UINT_FIELD(CTECycleClause, cycle_mark_type, cycle_mark_type, cycle_mark_type);
  READ_INT_FIELD(CTECycleClause, cycle_mark_typmod, cycle_mark_typmod, cycle_mark_typmod);
  READ_UINT_FIELD(CTECycleClause, cycle_mark_collation, cycle_mark_collation, cycle_mark_collation);
  READ_UINT_FIELD(CTECycleClause, cycle_mark_neop, cycle_mark_neop, cycle_mark_neop);
  return node;
}

static CommonTableExpr *
_readCommonTableExpr(const OUT_TYPE(CommonTableExpr, CommonTableExpr) msg)
{
  CommonTableExpr *node = makeNode(CommonTableExpr);
  READ_STRING_FIELD(CommonTableExpr, ctename, ctename, ctename);
  READ_LIST_FIELD(CommonTableExpr, aliascolnames, aliascolnames, aliascolnames);
  READ_ENUM_FIELD(CommonTableExpr, CTEMaterialize, ctematerialized, ctematerialized, ctematerialized);
  READ_NODE_PTR_FIELD(CommonTableExpr, ctequery, ctequery, ctequery);
  READ_SPECIFIC_NODE_PTR_FIELD(CommonTableExpr, CTESearchClause, ctesearch_clause, search_clause, search_clause, search_clause);
  READ_SPECIFIC_NODE_PTR_FIELD(CommonTableExpr, CTECycleClause, ctecycle_clause, cycle_clause, cycle_clause, cycle_clause);
  READ_INT_FIELD(CommonTableExpr, location, location, location);
  READ_BOOL_FIELD(CommonTableExpr, cterecursive, cterecursive, cterecursive);
  READ_INT_FIELD(CommonTableExpr, cterefcount, cterefcount, cterefcount);
  READ_LIST_FIELD(CommonTableExpr, ctecolnames, ctecolnames, ctecolnames);
  READ_LIST_FIELD(CommonTableExpr, ctecoltypes, ctecoltypes, ctecoltypes);
  READ_LIST_FIELD(CommonTableExpr, ctecoltypmods, ctecoltypmods, ctecoltypmods);
  READ_LIST_FIELD(CommonTableExpr, ctecolcollations, ctecolcollations, ctecolcollations);
  return node;
}

static MergeWhenClause *
_readMergeWhenClause(const OUT_TYPE(MergeWhenClause, MergeWhenClause) msg)
{
  MergeWhenClause *node = makeNode(MergeWhenClause);
  READ_ENUM_FIELD(MergeWhenClause, MergeMatchKind, match_kind, matchKind, matchKind);
  READ_ENUM_FIELD(MergeWhenClause, CmdType, command_type, commandType, commandType);
  READ_ENUM_FIELD(MergeWhenClause, OverridingKind, override, override, override);
  READ_NODE_PTR_FIELD(MergeWhenClause, condition, condition, condition);
  READ_LIST_FIELD(MergeWhenClause, target_list, targetList, targetList);
  READ_LIST_FIELD(MergeWhenClause, values, values, values);
  return node;
}

static ReturningOption *
_readReturningOption(const OUT_TYPE(ReturningOption, ReturningOption) msg)
{
  ReturningOption *node = makeNode(ReturningOption);
  READ_ENUM_FIELD(ReturningOption, ReturningOptionKind, option, option, option);
  READ_STRING_FIELD(ReturningOption, value, value, value);
  READ_INT_FIELD(ReturningOption, location, location, location);
  return node;
}

static ReturningClause *
_readReturningClause(const OUT_TYPE(ReturningClause, ReturningClause) msg)
{
  ReturningClause *node = makeNode(ReturningClause);
  READ_LIST_FIELD(ReturningClause, options, options, options);
  READ_LIST_FIELD(ReturningClause, exprs, exprs, exprs);
  return node;
}

static TriggerTransition *
_readTriggerTransition(const OUT_TYPE(TriggerTransition, TriggerTransition) msg)
{
  TriggerTransition *node = makeNode(TriggerTransition);
  READ_STRING_FIELD(TriggerTransition, name, name, name);
  READ_BOOL_FIELD(TriggerTransition, is_new, isNew, isNew);
  READ_BOOL_FIELD(TriggerTransition, is_table, isTable, isTable);
  return node;
}

static JsonOutput *
_readJsonOutput(const OUT_TYPE(JsonOutput, JsonOutput) msg)
{
  JsonOutput *node = makeNode(JsonOutput);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonOutput, TypeName, type_name, type_name, typeName, typeName);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonOutput, JsonReturning, json_returning, returning, returning, returning);
  return node;
}

static JsonArgument *
_readJsonArgument(const OUT_TYPE(JsonArgument, JsonArgument) msg)
{
  JsonArgument *node = makeNode(JsonArgument);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonArgument, JsonValueExpr, json_value_expr, val, val, val);
  READ_STRING_FIELD(JsonArgument, name, name, name);
  return node;
}

static JsonFuncExpr *
_readJsonFuncExpr(const OUT_TYPE(JsonFuncExpr, JsonFuncExpr) msg)
{
  JsonFuncExpr *node = makeNode(JsonFuncExpr);
  READ_ENUM_FIELD(JsonFuncExpr, JsonExprOp, op, op, op);
  READ_STRING_FIELD(JsonFuncExpr, column_name, column_name, column_name);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonFuncExpr, JsonValueExpr, json_value_expr, context_item, context_item, context_item);
  READ_NODE_PTR_FIELD(JsonFuncExpr, pathspec, pathspec, pathspec);
  READ_LIST_FIELD(JsonFuncExpr, passing, passing, passing);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonFuncExpr, JsonOutput, json_output, output, output, output);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonFuncExpr, JsonBehavior, json_behavior, on_empty, on_empty, on_empty);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonFuncExpr, JsonBehavior, json_behavior, on_error, on_error, on_error);
  READ_ENUM_FIELD(JsonFuncExpr, JsonWrapper, wrapper, wrapper, wrapper);
  READ_ENUM_FIELD(JsonFuncExpr, JsonQuotes, quotes, quotes, quotes);
  READ_INT_FIELD(JsonFuncExpr, location, location, location);
  return node;
}

static JsonTablePathSpec *
_readJsonTablePathSpec(const OUT_TYPE(JsonTablePathSpec, JsonTablePathSpec) msg)
{
  JsonTablePathSpec *node = makeNode(JsonTablePathSpec);
  READ_NODE_PTR_FIELD(JsonTablePathSpec, string, string, string);
  READ_STRING_FIELD(JsonTablePathSpec, name, name, name);
  READ_INT_FIELD(JsonTablePathSpec, name_location, name_location, name_location);
  READ_INT_FIELD(JsonTablePathSpec, location, location, location);
  return node;
}

static JsonTable *
_readJsonTable(const OUT_TYPE(JsonTable, JsonTable) msg)
{
  JsonTable *node = makeNode(JsonTable);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonTable, JsonValueExpr, json_value_expr, context_item, context_item, context_item);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonTable, JsonTablePathSpec, json_table_path_spec, pathspec, pathspec, pathspec);
  READ_LIST_FIELD(JsonTable, passing, passing, passing);
  READ_LIST_FIELD(JsonTable, columns, columns, columns);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonTable, JsonBehavior, json_behavior, on_error, on_error, on_error);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonTable, Alias, alias, alias, alias, alias);
  READ_BOOL_FIELD(JsonTable, lateral, lateral, lateral);
  READ_INT_FIELD(JsonTable, location, location, location);
  return node;
}

static JsonTableColumn *
_readJsonTableColumn(const OUT_TYPE(JsonTableColumn, JsonTableColumn) msg)
{
  JsonTableColumn *node = makeNode(JsonTableColumn);
  READ_ENUM_FIELD(JsonTableColumn, JsonTableColumnType, coltype, coltype, coltype);
  READ_STRING_FIELD(JsonTableColumn, name, name, name);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonTableColumn, TypeName, type_name, type_name, typeName, typeName);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonTableColumn, JsonTablePathSpec, json_table_path_spec, pathspec, pathspec, pathspec);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonTableColumn, JsonFormat, json_format, format, format, format);
  READ_ENUM_FIELD(JsonTableColumn, JsonWrapper, wrapper, wrapper, wrapper);
  READ_ENUM_FIELD(JsonTableColumn, JsonQuotes, quotes, quotes, quotes);
  READ_LIST_FIELD(JsonTableColumn, columns, columns, columns);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonTableColumn, JsonBehavior, json_behavior, on_empty, on_empty, on_empty);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonTableColumn, JsonBehavior, json_behavior, on_error, on_error, on_error);
  READ_INT_FIELD(JsonTableColumn, location, location, location);
  return node;
}

static JsonKeyValue *
_readJsonKeyValue(const OUT_TYPE(JsonKeyValue, JsonKeyValue) msg)
{
  JsonKeyValue *node = makeNode(JsonKeyValue);
  READ_ABSTRACT_PTR_FIELD(JsonKeyValue, key, key, key, Expr*);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonKeyValue, JsonValueExpr, json_value_expr, value, value, value);
  return node;
}

static JsonParseExpr *
_readJsonParseExpr(const OUT_TYPE(JsonParseExpr, JsonParseExpr) msg)
{
  JsonParseExpr *node = makeNode(JsonParseExpr);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonParseExpr, JsonValueExpr, json_value_expr, expr, expr, expr);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonParseExpr, JsonOutput, json_output, output, output, output);
  READ_BOOL_FIELD(JsonParseExpr, unique_keys, unique_keys, unique_keys);
  READ_INT_FIELD(JsonParseExpr, location, location, location);
  return node;
}

static JsonScalarExpr *
_readJsonScalarExpr(const OUT_TYPE(JsonScalarExpr, JsonScalarExpr) msg)
{
  JsonScalarExpr *node = makeNode(JsonScalarExpr);
  READ_ABSTRACT_PTR_FIELD(JsonScalarExpr, expr, expr, expr, Expr*);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonScalarExpr, JsonOutput, json_output, output, output, output);
  READ_INT_FIELD(JsonScalarExpr, location, location, location);
  return node;
}

static JsonSerializeExpr *
_readJsonSerializeExpr(const OUT_TYPE(JsonSerializeExpr, JsonSerializeExpr) msg)
{
  JsonSerializeExpr *node = makeNode(JsonSerializeExpr);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonSerializeExpr, JsonValueExpr, json_value_expr, expr, expr, expr);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonSerializeExpr, JsonOutput, json_output, output, output, output);
  READ_INT_FIELD(JsonSerializeExpr, location, location, location);
  return node;
}

static JsonObjectConstructor *
_readJsonObjectConstructor(const OUT_TYPE(JsonObjectConstructor, JsonObjectConstructor) msg)
{
  JsonObjectConstructor *node = makeNode(JsonObjectConstructor);
  READ_LIST_FIELD(JsonObjectConstructor, exprs, exprs, exprs);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonObjectConstructor, JsonOutput, json_output, output, output, output);
  READ_BOOL_FIELD(JsonObjectConstructor, absent_on_null, absent_on_null, absent_on_null);
  READ_BOOL_FIELD(JsonObjectConstructor, unique, unique, unique);
  READ_INT_FIELD(JsonObjectConstructor, location, location, location);
  return node;
}

static JsonArrayConstructor *
_readJsonArrayConstructor(const OUT_TYPE(JsonArrayConstructor, JsonArrayConstructor) msg)
{
  JsonArrayConstructor *node = makeNode(JsonArrayConstructor);
  READ_LIST_FIELD(JsonArrayConstructor, exprs, exprs, exprs);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonArrayConstructor, JsonOutput, json_output, output, output, output);
  READ_BOOL_FIELD(JsonArrayConstructor, absent_on_null, absent_on_null, absent_on_null);
  READ_INT_FIELD(JsonArrayConstructor, location, location, location);
  return node;
}

static JsonArrayQueryConstructor *
_readJsonArrayQueryConstructor(const OUT_TYPE(JsonArrayQueryConstructor, JsonArrayQueryConstructor) msg)
{
  JsonArrayQueryConstructor *node = makeNode(JsonArrayQueryConstructor);
  READ_NODE_PTR_FIELD(JsonArrayQueryConstructor, query, query, query);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonArrayQueryConstructor, JsonOutput, json_output, output, output, output);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonArrayQueryConstructor, JsonFormat, json_format, format, format, format);
  READ_BOOL_FIELD(JsonArrayQueryConstructor, absent_on_null, absent_on_null, absent_on_null);
  READ_INT_FIELD(JsonArrayQueryConstructor, location, location, location);
  return node;
}

static JsonAggConstructor *
_readJsonAggConstructor(const OUT_TYPE(JsonAggConstructor, JsonAggConstructor) msg)
{
  JsonAggConstructor *node = makeNode(JsonAggConstructor);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonAggConstructor, JsonOutput, json_output, output, output, output);
  READ_NODE_PTR_FIELD(JsonAggConstructor, agg_filter, agg_filter, agg_filter);
  READ_LIST_FIELD(JsonAggConstructor, agg_order, agg_order, agg_order);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonAggConstructor, WindowDef, window_def, over, over, over);
  READ_INT_FIELD(JsonAggConstructor, location, location, location);
  return node;
}

static JsonObjectAgg *
_readJsonObjectAgg(const OUT_TYPE(JsonObjectAgg, JsonObjectAgg) msg)
{
  JsonObjectAgg *node = makeNode(JsonObjectAgg);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonObjectAgg, JsonAggConstructor, json_agg_constructor, constructor, constructor, constructor);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonObjectAgg, JsonKeyValue, json_key_value, arg, arg, arg);
  READ_BOOL_FIELD(JsonObjectAgg, absent_on_null, absent_on_null, absent_on_null);
  READ_BOOL_FIELD(JsonObjectAgg, unique, unique, unique);
  return node;
}

static JsonArrayAgg *
_readJsonArrayAgg(const OUT_TYPE(JsonArrayAgg, JsonArrayAgg) msg)
{
  JsonArrayAgg *node = makeNode(JsonArrayAgg);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonArrayAgg, JsonAggConstructor, json_agg_constructor, constructor, constructor, constructor);
  READ_SPECIFIC_NODE_PTR_FIELD(JsonArrayAgg, JsonValueExpr, json_value_expr, arg, arg, arg);
  READ_BOOL_FIELD(JsonArrayAgg, absent_on_null, absent_on_null, absent_on_null);
  return node;
}

static RawStmt *
_readRawStmt(const OUT_TYPE(RawStmt, RawStmt) msg)
{
  RawStmt *node = makeNode(RawStmt);
  READ_NODE_PTR_FIELD(RawStmt, stmt, stmt, stmt);
  READ_INT_FIELD(RawStmt, stmt_location, stmt_location, stmt_location);
  READ_INT_FIELD(RawStmt, stmt_len, stmt_len, stmt_len);
  return node;
}

static InsertStmt *
_readInsertStmt(const OUT_TYPE(InsertStmt, InsertStmt) msg)
{
  InsertStmt *node = makeNode(InsertStmt);
  READ_SPECIFIC_NODE_PTR_FIELD(InsertStmt, RangeVar, range_var, relation, relation, relation);
  READ_LIST_FIELD(InsertStmt, cols, cols, cols);
  READ_NODE_PTR_FIELD(InsertStmt, select_stmt, selectStmt, selectStmt);
  READ_SPECIFIC_NODE_PTR_FIELD(InsertStmt, OnConflictClause, on_conflict_clause, on_conflict_clause, onConflictClause, onConflictClause);
  READ_SPECIFIC_NODE_PTR_FIELD(InsertStmt, ReturningClause, returning_clause, returning_clause, returningClause, returningClause);
  READ_SPECIFIC_NODE_PTR_FIELD(InsertStmt, WithClause, with_clause, with_clause, withClause, withClause);
  READ_ENUM_FIELD(InsertStmt, OverridingKind, override, override, override);
  return node;
}

static DeleteStmt *
_readDeleteStmt(const OUT_TYPE(DeleteStmt, DeleteStmt) msg)
{
  DeleteStmt *node = makeNode(DeleteStmt);
  READ_SPECIFIC_NODE_PTR_FIELD(DeleteStmt, RangeVar, range_var, relation, relation, relation);
  READ_LIST_FIELD(DeleteStmt, using_clause, usingClause, usingClause);
  READ_NODE_PTR_FIELD(DeleteStmt, where_clause, whereClause, whereClause);
  READ_SPECIFIC_NODE_PTR_FIELD(DeleteStmt, ReturningClause, returning_clause, returning_clause, returningClause, returningClause);
  READ_SPECIFIC_NODE_PTR_FIELD(DeleteStmt, WithClause, with_clause, with_clause, withClause, withClause);
  return node;
}

static UpdateStmt *
_readUpdateStmt(const OUT_TYPE(UpdateStmt, UpdateStmt) msg)
{
  UpdateStmt *node = makeNode(UpdateStmt);
  READ_SPECIFIC_NODE_PTR_FIELD(UpdateStmt, RangeVar, range_var, relation, relation, relation);
  READ_LIST_FIELD(UpdateStmt, target_list, targetList, targetList);
  READ_NODE_PTR_FIELD(UpdateStmt, where_clause, whereClause, whereClause);
  READ_LIST_FIELD(UpdateStmt, from_clause, fromClause, fromClause);
  READ_SPECIFIC_NODE_PTR_FIELD(UpdateStmt, ReturningClause, returning_clause, returning_clause, returningClause, returningClause);
  READ_SPECIFIC_NODE_PTR_FIELD(UpdateStmt, WithClause, with_clause, with_clause, withClause, withClause);
  return node;
}

static MergeStmt *
_readMergeStmt(const OUT_TYPE(MergeStmt, MergeStmt) msg)
{
  MergeStmt *node = makeNode(MergeStmt);
  READ_SPECIFIC_NODE_PTR_FIELD(MergeStmt, RangeVar, range_var, relation, relation, relation);
  READ_NODE_PTR_FIELD(MergeStmt, source_relation, sourceRelation, sourceRelation);
  READ_NODE_PTR_FIELD(MergeStmt, join_condition, joinCondition, joinCondition);
  READ_LIST_FIELD(MergeStmt, merge_when_clauses, mergeWhenClauses, mergeWhenClauses);
  READ_SPECIFIC_NODE_PTR_FIELD(MergeStmt, ReturningClause, returning_clause, returning_clause, returningClause, returningClause);
  READ_SPECIFIC_NODE_PTR_FIELD(MergeStmt, WithClause, with_clause, with_clause, withClause, withClause);
  return node;
}

static SelectStmt *
_readSelectStmt(const OUT_TYPE(SelectStmt, SelectStmt) msg)
{
  SelectStmt *node = makeNode(SelectStmt);
  READ_LIST_FIELD(SelectStmt, distinct_clause, distinctClause, distinctClause);
  READ_SPECIFIC_NODE_PTR_FIELD(SelectStmt, IntoClause, into_clause, into_clause, intoClause, intoClause);
  READ_LIST_FIELD(SelectStmt, target_list, targetList, targetList);
  READ_LIST_FIELD(SelectStmt, from_clause, fromClause, fromClause);
  READ_NODE_PTR_FIELD(SelectStmt, where_clause, whereClause, whereClause);
  READ_LIST_FIELD(SelectStmt, group_clause, groupClause, groupClause);
  READ_BOOL_FIELD(SelectStmt, group_distinct, groupDistinct, groupDistinct);
  READ_NODE_PTR_FIELD(SelectStmt, having_clause, havingClause, havingClause);
  READ_LIST_FIELD(SelectStmt, window_clause, windowClause, windowClause);
  READ_LIST_FIELD(SelectStmt, values_lists, valuesLists, valuesLists);
  READ_LIST_FIELD(SelectStmt, sort_clause, sortClause, sortClause);
  READ_NODE_PTR_FIELD(SelectStmt, limit_offset, limitOffset, limitOffset);
  READ_NODE_PTR_FIELD(SelectStmt, limit_count, limitCount, limitCount);
  READ_ENUM_FIELD(SelectStmt, LimitOption, limit_option, limitOption, limitOption);
  READ_LIST_FIELD(SelectStmt, locking_clause, lockingClause, lockingClause);
  READ_SPECIFIC_NODE_PTR_FIELD(SelectStmt, WithClause, with_clause, with_clause, withClause, withClause);
  READ_ENUM_FIELD(SelectStmt, SetOperation, op, op, op);
  READ_BOOL_FIELD(SelectStmt, all, all, all);
  READ_SPECIFIC_NODE_PTR_FIELD(SelectStmt, SelectStmt, select_stmt, larg, larg, larg);
  READ_SPECIFIC_NODE_PTR_FIELD(SelectStmt, SelectStmt, select_stmt, rarg, rarg, rarg);
  return node;
}

static SetOperationStmt *
_readSetOperationStmt(const OUT_TYPE(SetOperationStmt, SetOperationStmt) msg)
{
  SetOperationStmt *node = makeNode(SetOperationStmt);
  READ_ENUM_FIELD(SetOperationStmt, SetOperation, op, op, op);
  READ_BOOL_FIELD(SetOperationStmt, all, all, all);
  READ_NODE_PTR_FIELD(SetOperationStmt, larg, larg, larg);
  READ_NODE_PTR_FIELD(SetOperationStmt, rarg, rarg, rarg);
  READ_LIST_FIELD(SetOperationStmt, col_types, colTypes, colTypes);
  READ_LIST_FIELD(SetOperationStmt, col_typmods, colTypmods, colTypmods);
  READ_LIST_FIELD(SetOperationStmt, col_collations, colCollations, colCollations);
  READ_LIST_FIELD(SetOperationStmt, group_clauses, groupClauses, groupClauses);
  return node;
}

static ReturnStmt *
_readReturnStmt(const OUT_TYPE(ReturnStmt, ReturnStmt) msg)
{
  ReturnStmt *node = makeNode(ReturnStmt);
  READ_NODE_PTR_FIELD(ReturnStmt, returnval, returnval, returnval);
  return node;
}

static PLAssignStmt *
_readPLAssignStmt(const OUT_TYPE(PLAssignStmt, PLAssignStmt) msg)
{
  PLAssignStmt *node = makeNode(PLAssignStmt);
  READ_STRING_FIELD(PLAssignStmt, name, name, name);
  READ_LIST_FIELD(PLAssignStmt, indirection, indirection, indirection);
  READ_INT_FIELD(PLAssignStmt, nnames, nnames, nnames);
  READ_SPECIFIC_NODE_PTR_FIELD(PLAssignStmt, SelectStmt, select_stmt, val, val, val);
  READ_INT_FIELD(PLAssignStmt, location, location, location);
  return node;
}

static CreateSchemaStmt *
_readCreateSchemaStmt(const OUT_TYPE(CreateSchemaStmt, CreateSchemaStmt) msg)
{
  CreateSchemaStmt *node = makeNode(CreateSchemaStmt);
  READ_STRING_FIELD(CreateSchemaStmt, schemaname, schemaname, schemaname);
  READ_SPECIFIC_NODE_PTR_FIELD(CreateSchemaStmt, RoleSpec, role_spec, authrole, authrole, authrole);
  READ_LIST_FIELD(CreateSchemaStmt, schema_elts, schemaElts, schemaElts);
  READ_BOOL_FIELD(CreateSchemaStmt, if_not_exists, if_not_exists, if_not_exists);
  return node;
}

static AlterTableStmt *
_readAlterTableStmt(const OUT_TYPE(AlterTableStmt, AlterTableStmt) msg)
{
  AlterTableStmt *node = makeNode(AlterTableStmt);
  READ_SPECIFIC_NODE_PTR_FIELD(AlterTableStmt, RangeVar, range_var, relation, relation, relation);
  READ_LIST_FIELD(AlterTableStmt, cmds, cmds, cmds);
  READ_ENUM_FIELD(AlterTableStmt, ObjectType, objtype, objtype, objtype);
  READ_BOOL_FIELD(AlterTableStmt, missing_ok, missing_ok, missing_ok);
  return node;
}

static AlterTableCmd *
_readAlterTableCmd(const OUT_TYPE(AlterTableCmd, AlterTableCmd) msg)
{
  AlterTableCmd *node = makeNode(AlterTableCmd);
  READ_ENUM_FIELD(AlterTableCmd, AlterTableType, subtype, subtype, subtype);
  READ_STRING_FIELD(AlterTableCmd, name, name, name);
  READ_INT_FIELD(AlterTableCmd, num, num, num);
  READ_SPECIFIC_NODE_PTR_FIELD(AlterTableCmd, RoleSpec, role_spec, newowner, newowner, newowner);
  READ_NODE_PTR_FIELD(AlterTableCmd, def, def, def);
  READ_ENUM_FIELD(AlterTableCmd, DropBehavior, behavior, behavior, behavior);
  READ_BOOL_FIELD(AlterTableCmd, missing_ok, missing_ok, missing_ok);
  READ_BOOL_FIELD(AlterTableCmd, recurse, recurse, recurse);
  return node;
}

static ATAlterConstraint *
_readATAlterConstraint(const OUT_TYPE(ATAlterConstraint, ATAlterConstraint) msg)
{
  ATAlterConstraint *node = makeNode(ATAlterConstraint);
  READ_STRING_FIELD(ATAlterConstraint, conname, conname, conname);
  READ_BOOL_FIELD(ATAlterConstraint, alter_enforceability, alterEnforceability, alterEnforceability);
  READ_BOOL_FIELD(ATAlterConstraint, is_enforced, is_enforced, is_enforced);
  READ_BOOL_FIELD(ATAlterConstraint, alter_deferrability, alterDeferrability, alterDeferrability);
  READ_BOOL_FIELD(ATAlterConstraint, deferrable, deferrable, deferrable);
  READ_BOOL_FIELD(ATAlterConstraint, initdeferred, initdeferred, initdeferred);
  READ_BOOL_FIELD(ATAlterConstraint, alter_inheritability, alterInheritability, alterInheritability);
  READ_BOOL_FIELD(ATAlterConstraint, noinherit, noinherit, noinherit);
  return node;
}

static ReplicaIdentityStmt *
_readReplicaIdentityStmt(const OUT_TYPE(ReplicaIdentityStmt, ReplicaIdentityStmt) msg)
{
  ReplicaIdentityStmt *node = makeNode(ReplicaIdentityStmt);
  READ_CHAR_FIELD(ReplicaIdentityStmt, identity_type, identity_type, identity_type);
  READ_STRING_FIELD(ReplicaIdentityStmt, name, name, name);
  return node;
}

static AlterCollationStmt *
_readAlterCollationStmt(const OUT_TYPE(AlterCollationStmt, AlterCollationStmt) msg)
{
  AlterCollationStmt *node = makeNode(AlterCollationStmt);
  READ_LIST_FIELD(AlterCollationStmt, collname, collname, collname);
  return node;
}

static AlterDomainStmt *
_readAlterDomainStmt(const OUT_TYPE(AlterDomainStmt, AlterDomainStmt) msg)
{
  AlterDomainStmt *node = makeNode(AlterDomainStmt);
  READ_CHAR_FIELD(AlterDomainStmt, subtype, subtype, subtype);
  READ_LIST_FIELD(AlterDomainStmt, type_name, typeName, typeName);
  READ_STRING_FIELD(AlterDomainStmt, name, name, name);
  READ_NODE_PTR_FIELD(AlterDomainStmt, def, def, def);
  READ_ENUM_FIELD(AlterDomainStmt, DropBehavior, behavior, behavior, behavior);
  READ_BOOL_FIELD(AlterDomainStmt, missing_ok, missing_ok, missing_ok);
  return node;
}

static GrantStmt *
_readGrantStmt(const OUT_TYPE(GrantStmt, GrantStmt) msg)
{
  GrantStmt *node = makeNode(GrantStmt);
  READ_BOOL_FIELD(GrantStmt, is_grant, is_grant, is_grant);
  READ_ENUM_FIELD(GrantStmt, GrantTargetType, targtype, targtype, targtype);
  READ_ENUM_FIELD(GrantStmt, ObjectType, objtype, objtype, objtype);
  READ_LIST_FIELD(GrantStmt, objects, objects, objects);
  READ_LIST_FIELD(GrantStmt, privileges, privileges, privileges);
  READ_LIST_FIELD(GrantStmt, grantees, grantees, grantees);
  READ_BOOL_FIELD(GrantStmt, grant_option, grant_option, grant_option);
  READ_SPECIFIC_NODE_PTR_FIELD(GrantStmt, RoleSpec, role_spec, grantor, grantor, grantor);
  READ_ENUM_FIELD(GrantStmt, DropBehavior, behavior, behavior, behavior);
  return node;
}

static ObjectWithArgs *
_readObjectWithArgs(const OUT_TYPE(ObjectWithArgs, ObjectWithArgs) msg)
{
  ObjectWithArgs *node = makeNode(ObjectWithArgs);
  READ_LIST_FIELD(ObjectWithArgs, objname, objname, objname);
  READ_LIST_FIELD(ObjectWithArgs, objargs, objargs, objargs);
  READ_LIST_FIELD(ObjectWithArgs, objfuncargs, objfuncargs, objfuncargs);
  READ_BOOL_FIELD(ObjectWithArgs, args_unspecified, args_unspecified, args_unspecified);
  return node;
}

static AccessPriv *
_readAccessPriv(const OUT_TYPE(AccessPriv, AccessPriv) msg)
{
  AccessPriv *node = makeNode(AccessPriv);
  READ_STRING_FIELD(AccessPriv, priv_name, priv_name, priv_name);
  READ_LIST_FIELD(AccessPriv, cols, cols, cols);
  return node;
}

static GrantRoleStmt *
_readGrantRoleStmt(const OUT_TYPE(GrantRoleStmt, GrantRoleStmt) msg)
{
  GrantRoleStmt *node = makeNode(GrantRoleStmt);
  READ_LIST_FIELD(GrantRoleStmt, granted_roles, granted_roles, granted_roles);
  READ_LIST_FIELD(GrantRoleStmt, grantee_roles, grantee_roles, grantee_roles);
  READ_BOOL_FIELD(GrantRoleStmt, is_grant, is_grant, is_grant);
  READ_LIST_FIELD(GrantRoleStmt, opt, opt, opt);
  READ_SPECIFIC_NODE_PTR_FIELD(GrantRoleStmt, RoleSpec, role_spec, grantor, grantor, grantor);
  READ_ENUM_FIELD(GrantRoleStmt, DropBehavior, behavior, behavior, behavior);
  return node;
}

static AlterDefaultPrivilegesStmt *
_readAlterDefaultPrivilegesStmt(const OUT_TYPE(AlterDefaultPrivilegesStmt, AlterDefaultPrivilegesStmt) msg)
{
  AlterDefaultPrivilegesStmt *node = makeNode(AlterDefaultPrivilegesStmt);
  READ_LIST_FIELD(AlterDefaultPrivilegesStmt, options, options, options);
  READ_SPECIFIC_NODE_PTR_FIELD(AlterDefaultPrivilegesStmt, GrantStmt, grant_stmt, action, action, action);
  return node;
}

static CopyStmt *
_readCopyStmt(const OUT_TYPE(CopyStmt, CopyStmt) msg)
{
  CopyStmt *node = makeNode(CopyStmt);
  READ_SPECIFIC_NODE_PTR_FIELD(CopyStmt, RangeVar, range_var, relation, relation, relation);
  READ_NODE_PTR_FIELD(CopyStmt, query, query, query);
  READ_LIST_FIELD(CopyStmt, attlist, attlist, attlist);
  READ_BOOL_FIELD(CopyStmt, is_from, is_from, is_from);
  READ_BOOL_FIELD(CopyStmt, is_program, is_program, is_program);
  READ_STRING_FIELD(CopyStmt, filename, filename, filename);
  READ_LIST_FIELD(CopyStmt, options, options, options);
  READ_NODE_PTR_FIELD(CopyStmt, where_clause, whereClause, whereClause);
  return node;
}

static VariableSetStmt *
_readVariableSetStmt(const OUT_TYPE(VariableSetStmt, VariableSetStmt) msg)
{
  VariableSetStmt *node = makeNode(VariableSetStmt);
  READ_ENUM_FIELD(VariableSetStmt, VariableSetKind, kind, kind, kind);
  READ_STRING_FIELD(VariableSetStmt, name, name, name);
  READ_LIST_FIELD(VariableSetStmt, args, args, args);
  READ_BOOL_FIELD(VariableSetStmt, jumble_args, jumble_args, jumble_args);
  READ_BOOL_FIELD(VariableSetStmt, is_local, is_local, is_local);
  READ_INT_FIELD(VariableSetStmt, location, location, location);
  return node;
}

static VariableShowStmt *
_readVariableShowStmt(const OUT_TYPE(VariableShowStmt, VariableShowStmt) msg)
{
  VariableShowStmt *node = makeNode(VariableShowStmt);
  READ_STRING_FIELD(VariableShowStmt, name, name, name);
  return node;
}

static CreateStmt *
_readCreateStmt(const OUT_TYPE(CreateStmt, CreateStmt) msg)
{
  CreateStmt *node = makeNode(CreateStmt);
  READ_SPECIFIC_NODE_PTR_FIELD(CreateStmt, RangeVar, range_var, relation, relation, relation);
  READ_LIST_FIELD(CreateStmt, table_elts, tableElts, tableElts);
  READ_LIST_FIELD(CreateStmt, inh_relations, inhRelations, inhRelations);
  READ_SPECIFIC_NODE_PTR_FIELD(CreateStmt, PartitionBoundSpec, partition_bound_spec, partbound, partbound, partbound);
  READ_SPECIFIC_NODE_PTR_FIELD(CreateStmt, PartitionSpec, partition_spec, partspec, partspec, partspec);
  READ_SPECIFIC_NODE_PTR_FIELD(CreateStmt, TypeName, type_name, of_typename, ofTypename, ofTypename);
  READ_LIST_FIELD(CreateStmt, constraints, constraints, constraints);
  READ_LIST_FIELD(CreateStmt, nnconstraints, nnconstraints, nnconstraints);
  READ_LIST_FIELD(CreateStmt, options, options, options);
  READ_ENUM_FIELD(CreateStmt, OnCommitAction, oncommit, oncommit, oncommit);
  READ_STRING_FIELD(CreateStmt, tablespacename, tablespacename, tablespacename);
  READ_STRING_FIELD(CreateStmt, access_method, accessMethod, accessMethod);
  READ_BOOL_FIELD(CreateStmt, if_not_exists, if_not_exists, if_not_exists);
  return node;
}

static Constraint *
_readConstraint(const OUT_TYPE(Constraint, Constraint) msg)
{
  Constraint *node = makeNode(Constraint);
  READ_ENUM_FIELD(Constraint, ConstrType, contype, contype, contype);
  READ_STRING_FIELD(Constraint, conname, conname, conname);
  READ_BOOL_FIELD(Constraint, deferrable, deferrable, deferrable);
  READ_BOOL_FIELD(Constraint, initdeferred, initdeferred, initdeferred);
  READ_BOOL_FIELD(Constraint, is_enforced, is_enforced, is_enforced);
  READ_BOOL_FIELD(Constraint, skip_validation, skip_validation, skip_validation);
  READ_BOOL_FIELD(Constraint, initially_valid, initially_valid, initially_valid);
  READ_BOOL_FIELD(Constraint, is_no_inherit, is_no_inherit, is_no_inherit);
  READ_NODE_PTR_FIELD(Constraint, raw_expr, raw_expr, raw_expr);
  READ_STRING_FIELD(Constraint, cooked_expr, cooked_expr, cooked_expr);
  READ_CHAR_FIELD(Constraint, generated_when, generated_when, generated_when);
  READ_CHAR_FIELD(Constraint, generated_kind, generated_kind, generated_kind);
  READ_BOOL_FIELD(Constraint, nulls_not_distinct, nulls_not_distinct, nulls_not_distinct);
  READ_LIST_FIELD(Constraint, keys, keys, keys);
  READ_BOOL_FIELD(Constraint, without_overlaps, without_overlaps, without_overlaps);
  READ_LIST_FIELD(Constraint, including, including, including);
  READ_LIST_FIELD(Constraint, exclusions, exclusions, exclusions);
  READ_LIST_FIELD(Constraint, options, options, options);
  READ_STRING_FIELD(Constraint, indexname, indexname, indexname);
  READ_STRING_FIELD(Constraint, indexspace, indexspace, indexspace);
  READ_BOOL_FIELD(Constraint, reset_default_tblspc, reset_default_tblspc, reset_default_tblspc);
  READ_STRING_FIELD(Constraint, access_method, access_method, access_method);
  READ_NODE_PTR_FIELD(Constraint, where_clause, where_clause, where_clause);
  READ_SPECIFIC_NODE_PTR_FIELD(Constraint, RangeVar, range_var, pktable, pktable, pktable);
  READ_LIST_FIELD(Constraint, fk_attrs, fk_attrs, fk_attrs);
  READ_LIST_FIELD(Constraint, pk_attrs, pk_attrs, pk_attrs);
  READ_BOOL_FIELD(Constraint, fk_with_period, fk_with_period, fk_with_period);
  READ_BOOL_FIELD(Constraint, pk_with_period, pk_with_period, pk_with_period);
  READ_CHAR_FIELD(Constraint, fk_matchtype, fk_matchtype, fk_matchtype);
  READ_CHAR_FIELD(Constraint, fk_upd_action, fk_upd_action, fk_upd_action);
  READ_CHAR_FIELD(Constraint, fk_del_action, fk_del_action, fk_del_action);
  READ_LIST_FIELD(Constraint, fk_del_set_cols, fk_del_set_cols, fk_del_set_cols);
  READ_LIST_FIELD(Constraint, old_conpfeqop, old_conpfeqop, old_conpfeqop);
  READ_UINT_FIELD(Constraint, old_pktable_oid, old_pktable_oid, old_pktable_oid);
  READ_INT_FIELD(Constraint, location, location, location);
  return node;
}

static CreateTableSpaceStmt *
_readCreateTableSpaceStmt(const OUT_TYPE(CreateTableSpaceStmt, CreateTableSpaceStmt) msg)
{
  CreateTableSpaceStmt *node = makeNode(CreateTableSpaceStmt);
  READ_STRING_FIELD(CreateTableSpaceStmt, tablespacename, tablespacename, tablespacename);
  READ_SPECIFIC_NODE_PTR_FIELD(CreateTableSpaceStmt, RoleSpec, role_spec, owner, owner, owner);
  READ_STRING_FIELD(CreateTableSpaceStmt, location, location, location);
  READ_LIST_FIELD(CreateTableSpaceStmt, options, options, options);
  return node;
}

static DropTableSpaceStmt *
_readDropTableSpaceStmt(const OUT_TYPE(DropTableSpaceStmt, DropTableSpaceStmt) msg)
{
  DropTableSpaceStmt *node = makeNode(DropTableSpaceStmt);
  READ_STRING_FIELD(DropTableSpaceStmt, tablespacename, tablespacename, tablespacename);
  READ_BOOL_FIELD(DropTableSpaceStmt, missing_ok, missing_ok, missing_ok);
  return node;
}

static AlterTableSpaceOptionsStmt *
_readAlterTableSpaceOptionsStmt(const OUT_TYPE(AlterTableSpaceOptionsStmt, AlterTableSpaceOptionsStmt) msg)
{
  AlterTableSpaceOptionsStmt *node = makeNode(AlterTableSpaceOptionsStmt);
  READ_STRING_FIELD(AlterTableSpaceOptionsStmt, tablespacename, tablespacename, tablespacename);
  READ_LIST_FIELD(AlterTableSpaceOptionsStmt, options, options, options);
  READ_BOOL_FIELD(AlterTableSpaceOptionsStmt, is_reset, isReset, isReset);
  return node;
}

static AlterTableMoveAllStmt *
_readAlterTableMoveAllStmt(const OUT_TYPE(AlterTableMoveAllStmt, AlterTableMoveAllStmt) msg)
{
  AlterTableMoveAllStmt *node = makeNode(AlterTableMoveAllStmt);
  READ_STRING_FIELD(AlterTableMoveAllStmt, orig_tablespacename, orig_tablespacename, orig_tablespacename);
  READ_ENUM_FIELD(AlterTableMoveAllStmt, ObjectType, objtype, objtype, objtype);
  READ_LIST_FIELD(AlterTableMoveAllStmt, roles, roles, roles);
  READ_STRING_FIELD(AlterTableMoveAllStmt, new_tablespacename, new_tablespacename, new_tablespacename);
  READ_BOOL_FIELD(AlterTableMoveAllStmt, nowait, nowait, nowait);
  return node;
}

static CreateExtensionStmt *
_readCreateExtensionStmt(const OUT_TYPE(CreateExtensionStmt, CreateExtensionStmt) msg)
{
  CreateExtensionStmt *node = makeNode(CreateExtensionStmt);
  READ_STRING_FIELD(CreateExtensionStmt, extname, extname, extname);
  READ_BOOL_FIELD(CreateExtensionStmt, if_not_exists, if_not_exists, if_not_exists);
  READ_LIST_FIELD(CreateExtensionStmt, options, options, options);
  return node;
}

static AlterExtensionStmt *
_readAlterExtensionStmt(const OUT_TYPE(AlterExtensionStmt, AlterExtensionStmt) msg)
{
  AlterExtensionStmt *node = makeNode(AlterExtensionStmt);
  READ_STRING_FIELD(AlterExtensionStmt, extname, extname, extname);
  READ_LIST_FIELD(AlterExtensionStmt, options, options, options);
  return node;
}

static AlterExtensionContentsStmt *
_readAlterExtensionContentsStmt(const OUT_TYPE(AlterExtensionContentsStmt, AlterExtensionContentsStmt) msg)
{
  AlterExtensionContentsStmt *node = makeNode(AlterExtensionContentsStmt);
  READ_STRING_FIELD(AlterExtensionContentsStmt, extname, extname, extname);
  READ_INT_FIELD(AlterExtensionContentsStmt, action, action, action);
  READ_ENUM_FIELD(AlterExtensionContentsStmt, ObjectType, objtype, objtype, objtype);
  READ_NODE_PTR_FIELD(AlterExtensionContentsStmt, object, object, object);
  return node;
}

static CreateFdwStmt *
_readCreateFdwStmt(const OUT_TYPE(CreateFdwStmt, CreateFdwStmt) msg)
{
  CreateFdwStmt *node = makeNode(CreateFdwStmt);
  READ_STRING_FIELD(CreateFdwStmt, fdwname, fdwname, fdwname);
  READ_LIST_FIELD(CreateFdwStmt, func_options, func_options, func_options);
  READ_LIST_FIELD(CreateFdwStmt, options, options, options);
  return node;
}

static AlterFdwStmt *
_readAlterFdwStmt(const OUT_TYPE(AlterFdwStmt, AlterFdwStmt) msg)
{
  AlterFdwStmt *node = makeNode(AlterFdwStmt);
  READ_STRING_FIELD(AlterFdwStmt, fdwname, fdwname, fdwname);
  READ_LIST_FIELD(AlterFdwStmt, func_options, func_options, func_options);
  READ_LIST_FIELD(AlterFdwStmt, options, options, options);
  return node;
}

static CreateForeignServerStmt *
_readCreateForeignServerStmt(const OUT_TYPE(CreateForeignServerStmt, CreateForeignServerStmt) msg)
{
  CreateForeignServerStmt *node = makeNode(CreateForeignServerStmt);
  READ_STRING_FIELD(CreateForeignServerStmt, servername, servername, servername);
  READ_STRING_FIELD(CreateForeignServerStmt, servertype, servertype, servertype);
  READ_STRING_FIELD(CreateForeignServerStmt, version, version, version);
  READ_STRING_FIELD(CreateForeignServerStmt, fdwname, fdwname, fdwname);
  READ_BOOL_FIELD(CreateForeignServerStmt, if_not_exists, if_not_exists, if_not_exists);
  READ_LIST_FIELD(CreateForeignServerStmt, options, options, options);
  return node;
}

static AlterForeignServerStmt *
_readAlterForeignServerStmt(const OUT_TYPE(AlterForeignServerStmt, AlterForeignServerStmt) msg)
{
  AlterForeignServerStmt *node = makeNode(AlterForeignServerStmt);
  READ_STRING_FIELD(AlterForeignServerStmt, servername, servername, servername);
  READ_STRING_FIELD(AlterForeignServerStmt, version, version, version);
  READ_LIST_FIELD(AlterForeignServerStmt, options, options, options);
  READ_BOOL_FIELD(AlterForeignServerStmt, has_version, has_version, has_version);
  return node;
}

static CreateForeignTableStmt *
_readCreateForeignTableStmt(const OUT_TYPE(CreateForeignTableStmt, CreateForeignTableStmt) msg)
{
  CreateForeignTableStmt *node = makeNode(CreateForeignTableStmt);
  READ_SPECIFIC_NODE_FIELD(CreateForeignTableStmt, CreateStmt, create_stmt, base_stmt, base, base);
  READ_STRING_FIELD(CreateForeignTableStmt, servername, servername, servername);
  READ_LIST_FIELD(CreateForeignTableStmt, options, options, options);
  NodeSetTag(node, T_CreateForeignTableStmt);
  return node;
}

static CreateUserMappingStmt *
_readCreateUserMappingStmt(const OUT_TYPE(CreateUserMappingStmt, CreateUserMappingStmt) msg)
{
  CreateUserMappingStmt *node = makeNode(CreateUserMappingStmt);
  READ_SPECIFIC_NODE_PTR_FIELD(CreateUserMappingStmt, RoleSpec, role_spec, user, user, user);
  READ_STRING_FIELD(CreateUserMappingStmt, servername, servername, servername);
  READ_BOOL_FIELD(CreateUserMappingStmt, if_not_exists, if_not_exists, if_not_exists);
  READ_LIST_FIELD(CreateUserMappingStmt, options, options, options);
  return node;
}

static AlterUserMappingStmt *
_readAlterUserMappingStmt(const OUT_TYPE(AlterUserMappingStmt, AlterUserMappingStmt) msg)
{
  AlterUserMappingStmt *node = makeNode(AlterUserMappingStmt);
  READ_SPECIFIC_NODE_PTR_FIELD(AlterUserMappingStmt, RoleSpec, role_spec, user, user, user);
  READ_STRING_FIELD(AlterUserMappingStmt, servername, servername, servername);
  READ_LIST_FIELD(AlterUserMappingStmt, options, options, options);
  return node;
}

static DropUserMappingStmt *
_readDropUserMappingStmt(const OUT_TYPE(DropUserMappingStmt, DropUserMappingStmt) msg)
{
  DropUserMappingStmt *node = makeNode(DropUserMappingStmt);
  READ_SPECIFIC_NODE_PTR_FIELD(DropUserMappingStmt, RoleSpec, role_spec, user, user, user);
  READ_STRING_FIELD(DropUserMappingStmt, servername, servername, servername);
  READ_BOOL_FIELD(DropUserMappingStmt, missing_ok, missing_ok, missing_ok);
  return node;
}

static ImportForeignSchemaStmt *
_readImportForeignSchemaStmt(const OUT_TYPE(ImportForeignSchemaStmt, ImportForeignSchemaStmt) msg)
{
  ImportForeignSchemaStmt *node = makeNode(ImportForeignSchemaStmt);
  READ_STRING_FIELD(ImportForeignSchemaStmt, server_name, server_name, server_name);
  READ_STRING_FIELD(ImportForeignSchemaStmt, remote_schema, remote_schema, remote_schema);
  READ_STRING_FIELD(ImportForeignSchemaStmt, local_schema, local_schema, local_schema);
  READ_ENUM_FIELD(ImportForeignSchemaStmt, ImportForeignSchemaType, list_type, list_type, list_type);
  READ_LIST_FIELD(ImportForeignSchemaStmt, table_list, table_list, table_list);
  READ_LIST_FIELD(ImportForeignSchemaStmt, options, options, options);
  return node;
}

static CreatePolicyStmt *
_readCreatePolicyStmt(const OUT_TYPE(CreatePolicyStmt, CreatePolicyStmt) msg)
{
  CreatePolicyStmt *node = makeNode(CreatePolicyStmt);
  READ_STRING_FIELD(CreatePolicyStmt, policy_name, policy_name, policy_name);
  READ_SPECIFIC_NODE_PTR_FIELD(CreatePolicyStmt, RangeVar, range_var, table, table, table);
  READ_STRING_FIELD(CreatePolicyStmt, cmd_name, cmd_name, cmd_name);
  READ_BOOL_FIELD(CreatePolicyStmt, permissive, permissive, permissive);
  READ_LIST_FIELD(CreatePolicyStmt, roles, roles, roles);
  READ_NODE_PTR_FIELD(CreatePolicyStmt, qual, qual, qual);
  READ_NODE_PTR_FIELD(CreatePolicyStmt, with_check, with_check, with_check);
  return node;
}

static AlterPolicyStmt *
_readAlterPolicyStmt(const OUT_TYPE(AlterPolicyStmt, AlterPolicyStmt) msg)
{
  AlterPolicyStmt *node = makeNode(AlterPolicyStmt);
  READ_STRING_FIELD(AlterPolicyStmt, policy_name, policy_name, policy_name);
  READ_SPECIFIC_NODE_PTR_FIELD(AlterPolicyStmt, RangeVar, range_var, table, table, table);
  READ_LIST_FIELD(AlterPolicyStmt, roles, roles, roles);
  READ_NODE_PTR_FIELD(AlterPolicyStmt, qual, qual, qual);
  READ_NODE_PTR_FIELD(AlterPolicyStmt, with_check, with_check, with_check);
  return node;
}

static CreateAmStmt *
_readCreateAmStmt(const OUT_TYPE(CreateAmStmt, CreateAmStmt) msg)
{
  CreateAmStmt *node = makeNode(CreateAmStmt);
  READ_STRING_FIELD(CreateAmStmt, amname, amname, amname);
  READ_LIST_FIELD(CreateAmStmt, handler_name, handler_name, handler_name);
  READ_CHAR_FIELD(CreateAmStmt, amtype, amtype, amtype);
  return node;
}

static CreateTrigStmt *
_readCreateTrigStmt(const OUT_TYPE(CreateTrigStmt, CreateTrigStmt) msg)
{
  CreateTrigStmt *node = makeNode(CreateTrigStmt);
  READ_BOOL_FIELD(CreateTrigStmt, replace, replace, replace);
  READ_BOOL_FIELD(CreateTrigStmt, isconstraint, isconstraint, isconstraint);
  READ_STRING_FIELD(CreateTrigStmt, trigname, trigname, trigname);
  READ_SPECIFIC_NODE_PTR_FIELD(CreateTrigStmt, RangeVar, range_var, relation, relation, relation);
  READ_LIST_FIELD(CreateTrigStmt, funcname, funcname, funcname);
  READ_LIST_FIELD(CreateTrigStmt, args, args, args);
  READ_BOOL_FIELD(CreateTrigStmt, row, row, row);
  READ_INT_FIELD(CreateTrigStmt, timing, timing, timing);
  READ_INT_FIELD(CreateTrigStmt, events, events, events);
  READ_LIST_FIELD(CreateTrigStmt, columns, columns, columns);
  READ_NODE_PTR_FIELD(CreateTrigStmt, when_clause, whenClause, whenClause);
  READ_LIST_FIELD(CreateTrigStmt, transition_rels, transitionRels, transitionRels);
  READ_BOOL_FIELD(CreateTrigStmt, deferrable, deferrable, deferrable);
  READ_BOOL_FIELD(CreateTrigStmt, initdeferred, initdeferred, initdeferred);
  READ_SPECIFIC_NODE_PTR_FIELD(CreateTrigStmt, RangeVar, range_var, constrrel, constrrel, constrrel);
  return node;
}

static CreateEventTrigStmt *
_readCreateEventTrigStmt(const OUT_TYPE(CreateEventTrigStmt, CreateEventTrigStmt) msg)
{
  CreateEventTrigStmt *node = makeNode(CreateEventTrigStmt);
  READ_STRING_FIELD(CreateEventTrigStmt, trigname, trigname, trigname);
  READ_STRING_FIELD(CreateEventTrigStmt, eventname, eventname, eventname);
  READ_LIST_FIELD(CreateEventTrigStmt, whenclause, whenclause, whenclause);
  READ_LIST_FIELD(CreateEventTrigStmt, funcname, funcname, funcname);
  return node;
}

static AlterEventTrigStmt *
_readAlterEventTrigStmt(const OUT_TYPE(AlterEventTrigStmt, AlterEventTrigStmt) msg)
{
  AlterEventTrigStmt *node = makeNode(AlterEventTrigStmt);
  READ_STRING_FIELD(AlterEventTrigStmt, trigname, trigname, trigname);
  READ_CHAR_FIELD(AlterEventTrigStmt, tgenabled, tgenabled, tgenabled);
  return node;
}

static CreatePLangStmt *
_readCreatePLangStmt(const OUT_TYPE(CreatePLangStmt, CreatePLangStmt) msg)
{
  CreatePLangStmt *node = makeNode(CreatePLangStmt);
  READ_BOOL_FIELD(CreatePLangStmt, replace, replace, replace);
  READ_STRING_FIELD(CreatePLangStmt, plname, plname, plname);
  READ_LIST_FIELD(CreatePLangStmt, plhandler, plhandler, plhandler);
  READ_LIST_FIELD(CreatePLangStmt, plinline, plinline, plinline);
  READ_LIST_FIELD(CreatePLangStmt, plvalidator, plvalidator, plvalidator);
  READ_BOOL_FIELD(CreatePLangStmt, pltrusted, pltrusted, pltrusted);
  return node;
}

static CreateRoleStmt *
_readCreateRoleStmt(const OUT_TYPE(CreateRoleStmt, CreateRoleStmt) msg)
{
  CreateRoleStmt *node = makeNode(CreateRoleStmt);
  READ_ENUM_FIELD(CreateRoleStmt, RoleStmtType, stmt_type, stmt_type, stmt_type);
  READ_STRING_FIELD(CreateRoleStmt, role, role, role);
  READ_LIST_FIELD(CreateRoleStmt, options, options, options);
  return node;
}

static AlterRoleStmt *
_readAlterRoleStmt(const OUT_TYPE(AlterRoleStmt, AlterRoleStmt) msg)
{
  AlterRoleStmt *node = makeNode(AlterRoleStmt);
  READ_SPECIFIC_NODE_PTR_FIELD(AlterRoleStmt, RoleSpec, role_spec, role, role, role);
  READ_LIST_FIELD(AlterRoleStmt, options, options, options);
  READ_INT_FIELD(AlterRoleStmt, action, action, action);
  return node;
}

static AlterRoleSetStmt *
_readAlterRoleSetStmt(const OUT_TYPE(AlterRoleSetStmt, AlterRoleSetStmt) msg)
{
  AlterRoleSetStmt *node = makeNode(AlterRoleSetStmt);
  READ_SPECIFIC_NODE_PTR_FIELD(AlterRoleSetStmt, RoleSpec, role_spec, role, role, role);
  READ_STRING_FIELD(AlterRoleSetStmt, database, database, database);
  READ_SPECIFIC_NODE_PTR_FIELD(AlterRoleSetStmt, VariableSetStmt, variable_set_stmt, setstmt, setstmt, setstmt);
  return node;
}

static DropRoleStmt *
_readDropRoleStmt(const OUT_TYPE(DropRoleStmt, DropRoleStmt) msg)
{
  DropRoleStmt *node = makeNode(DropRoleStmt);
  READ_LIST_FIELD(DropRoleStmt, roles, roles, roles);
  READ_BOOL_FIELD(DropRoleStmt, missing_ok, missing_ok, missing_ok);
  return node;
}

static CreateSeqStmt *
_readCreateSeqStmt(const OUT_TYPE(CreateSeqStmt, CreateSeqStmt) msg)
{
  CreateSeqStmt *node = makeNode(CreateSeqStmt);
  READ_SPECIFIC_NODE_PTR_FIELD(CreateSeqStmt, RangeVar, range_var, sequence, sequence, sequence);
  READ_LIST_FIELD(CreateSeqStmt, options, options, options);
  READ_UINT_FIELD(CreateSeqStmt, owner_id, ownerId, ownerId);
  READ_BOOL_FIELD(CreateSeqStmt, for_identity, for_identity, for_identity);
  READ_BOOL_FIELD(CreateSeqStmt, if_not_exists, if_not_exists, if_not_exists);
  return node;
}

static AlterSeqStmt *
_readAlterSeqStmt(const OUT_TYPE(AlterSeqStmt, AlterSeqStmt) msg)
{
  AlterSeqStmt *node = makeNode(AlterSeqStmt);
  READ_SPECIFIC_NODE_PTR_FIELD(AlterSeqStmt, RangeVar, range_var, sequence, sequence, sequence);
  READ_LIST_FIELD(AlterSeqStmt, options, options, options);
  READ_BOOL_FIELD(AlterSeqStmt, for_identity, for_identity, for_identity);
  READ_BOOL_FIELD(AlterSeqStmt, missing_ok, missing_ok, missing_ok);
  return node;
}

static DefineStmt *
_readDefineStmt(const OUT_TYPE(DefineStmt, DefineStmt) msg)
{
  DefineStmt *node = makeNode(DefineStmt);
  READ_ENUM_FIELD(DefineStmt, ObjectType, kind, kind, kind);
  READ_BOOL_FIELD(DefineStmt, oldstyle, oldstyle, oldstyle);
  READ_LIST_FIELD(DefineStmt, defnames, defnames, defnames);
  READ_LIST_FIELD(DefineStmt, args, args, args);
  READ_LIST_FIELD(DefineStmt, definition, definition, definition);
  READ_BOOL_FIELD(DefineStmt, if_not_exists, if_not_exists, if_not_exists);
  READ_BOOL_FIELD(DefineStmt, replace, replace, replace);
  return node;
}

static CreateDomainStmt *
_readCreateDomainStmt(const OUT_TYPE(CreateDomainStmt, CreateDomainStmt) msg)
{
  CreateDomainStmt *node = makeNode(CreateDomainStmt);
  READ_LIST_FIELD(CreateDomainStmt, domainname, domainname, domainname);
  READ_SPECIFIC_NODE_PTR_FIELD(CreateDomainStmt, TypeName, type_name, type_name, typeName, typeName);
  READ_SPECIFIC_NODE_PTR_FIELD(CreateDomainStmt, CollateClause, collate_clause, coll_clause, collClause, collClause);
  READ_LIST_FIELD(CreateDomainStmt, constraints, constraints, constraints);
  return node;
}

static CreateOpClassStmt *
_readCreateOpClassStmt(const OUT_TYPE(CreateOpClassStmt, CreateOpClassStmt) msg)
{
  CreateOpClassStmt *node = makeNode(CreateOpClassStmt);
  READ_LIST_FIELD(CreateOpClassStmt, opclassname, opclassname, opclassname);
  READ_LIST_FIELD(CreateOpClassStmt, opfamilyname, opfamilyname, opfamilyname);
  READ_STRING_FIELD(CreateOpClassStmt, amname, amname, amname);
  READ_SPECIFIC_NODE_PTR_FIELD(CreateOpClassStmt, TypeName, type_name, datatype, datatype, datatype);
  READ_LIST_FIELD(CreateOpClassStmt, items, items, items);
  READ_BOOL_FIELD(CreateOpClassStmt, is_default, isDefault, isDefault);
  return node;
}

static CreateOpClassItem *
_readCreateOpClassItem(const OUT_TYPE(CreateOpClassItem, CreateOpClassItem) msg)
{
  CreateOpClassItem *node = makeNode(CreateOpClassItem);
  READ_INT_FIELD(CreateOpClassItem, itemtype, itemtype, itemtype);
  READ_SPECIFIC_NODE_PTR_FIELD(CreateOpClassItem, ObjectWithArgs, object_with_args, name, name, name);
  READ_INT_FIELD(CreateOpClassItem, number, number, number);
  READ_LIST_FIELD(CreateOpClassItem, order_family, order_family, order_family);
  READ_LIST_FIELD(CreateOpClassItem, class_args, class_args, class_args);
  READ_SPECIFIC_NODE_PTR_FIELD(CreateOpClassItem, TypeName, type_name, storedtype, storedtype, storedtype);
  return node;
}

static CreateOpFamilyStmt *
_readCreateOpFamilyStmt(const OUT_TYPE(CreateOpFamilyStmt, CreateOpFamilyStmt) msg)
{
  CreateOpFamilyStmt *node = makeNode(CreateOpFamilyStmt);
  READ_LIST_FIELD(CreateOpFamilyStmt, opfamilyname, opfamilyname, opfamilyname);
  READ_STRING_FIELD(CreateOpFamilyStmt, amname, amname, amname);
  return node;
}

static AlterOpFamilyStmt *
_readAlterOpFamilyStmt(const OUT_TYPE(AlterOpFamilyStmt, AlterOpFamilyStmt) msg)
{
  AlterOpFamilyStmt *node = makeNode(AlterOpFamilyStmt);
  READ_LIST_FIELD(AlterOpFamilyStmt, opfamilyname, opfamilyname, opfamilyname);
  READ_STRING_FIELD(AlterOpFamilyStmt, amname, amname, amname);
  READ_BOOL_FIELD(AlterOpFamilyStmt, is_drop, isDrop, isDrop);
  READ_LIST_FIELD(AlterOpFamilyStmt, items, items, items);
  return node;
}

static DropStmt *
_readDropStmt(const OUT_TYPE(DropStmt, DropStmt) msg)
{
  DropStmt *node = makeNode(DropStmt);
  READ_LIST_FIELD(DropStmt, objects, objects, objects);
  READ_ENUM_FIELD(DropStmt, ObjectType, remove_type, removeType, removeType);
  READ_ENUM_FIELD(DropStmt, DropBehavior, behavior, behavior, behavior);
  READ_BOOL_FIELD(DropStmt, missing_ok, missing_ok, missing_ok);
  READ_BOOL_FIELD(DropStmt, concurrent, concurrent, concurrent);
  return node;
}

static TruncateStmt *
_readTruncateStmt(const OUT_TYPE(TruncateStmt, TruncateStmt) msg)
{
  TruncateStmt *node = makeNode(TruncateStmt);
  READ_LIST_FIELD(TruncateStmt, relations, relations, relations);
  READ_BOOL_FIELD(TruncateStmt, restart_seqs, restart_seqs, restart_seqs);
  READ_ENUM_FIELD(TruncateStmt, DropBehavior, behavior, behavior, behavior);
  return node;
}

static CommentStmt *
_readCommentStmt(const OUT_TYPE(CommentStmt, CommentStmt) msg)
{
  CommentStmt *node = makeNode(CommentStmt);
  READ_ENUM_FIELD(CommentStmt, ObjectType, objtype, objtype, objtype);
  READ_NODE_PTR_FIELD(CommentStmt, object, object, object);
  READ_STRING_FIELD(CommentStmt, comment, comment, comment);
  return node;
}

static SecLabelStmt *
_readSecLabelStmt(const OUT_TYPE(SecLabelStmt, SecLabelStmt) msg)
{
  SecLabelStmt *node = makeNode(SecLabelStmt);
  READ_ENUM_FIELD(SecLabelStmt, ObjectType, objtype, objtype, objtype);
  READ_NODE_PTR_FIELD(SecLabelStmt, object, object, object);
  READ_STRING_FIELD(SecLabelStmt, provider, provider, provider);
  READ_STRING_FIELD(SecLabelStmt, label, label, label);
  return node;
}

static DeclareCursorStmt *
_readDeclareCursorStmt(const OUT_TYPE(DeclareCursorStmt, DeclareCursorStmt) msg)
{
  DeclareCursorStmt *node = makeNode(DeclareCursorStmt);
  READ_STRING_FIELD(DeclareCursorStmt, portalname, portalname, portalname);
  READ_INT_FIELD(DeclareCursorStmt, options, options, options);
  READ_NODE_PTR_FIELD(DeclareCursorStmt, query, query, query);
  return node;
}

static ClosePortalStmt *
_readClosePortalStmt(const OUT_TYPE(ClosePortalStmt, ClosePortalStmt) msg)
{
  ClosePortalStmt *node = makeNode(ClosePortalStmt);
  READ_STRING_FIELD(ClosePortalStmt, portalname, portalname, portalname);
  return node;
}

static FetchStmt *
_readFetchStmt(const OUT_TYPE(FetchStmt, FetchStmt) msg)
{
  FetchStmt *node = makeNode(FetchStmt);
  READ_ENUM_FIELD(FetchStmt, FetchDirection, direction, direction, direction);
  READ_LONG_FIELD(FetchStmt, how_many, howMany, howMany);
  READ_STRING_FIELD(FetchStmt, portalname, portalname, portalname);
  READ_BOOL_FIELD(FetchStmt, ismove, ismove, ismove);
  return node;
}

static IndexStmt *
_readIndexStmt(const OUT_TYPE(IndexStmt, IndexStmt) msg)
{
  IndexStmt *node = makeNode(IndexStmt);
  READ_STRING_FIELD(IndexStmt, idxname, idxname, idxname);
  READ_SPECIFIC_NODE_PTR_FIELD(IndexStmt, RangeVar, range_var, relation, relation, relation);
  READ_STRING_FIELD(IndexStmt, access_method, accessMethod, accessMethod);
  READ_STRING_FIELD(IndexStmt, table_space, tableSpace, tableSpace);
  READ_LIST_FIELD(IndexStmt, index_params, indexParams, indexParams);
  READ_LIST_FIELD(IndexStmt, index_including_params, indexIncludingParams, indexIncludingParams);
  READ_LIST_FIELD(IndexStmt, options, options, options);
  READ_NODE_PTR_FIELD(IndexStmt, where_clause, whereClause, whereClause);
  READ_LIST_FIELD(IndexStmt, exclude_op_names, excludeOpNames, excludeOpNames);
  READ_STRING_FIELD(IndexStmt, idxcomment, idxcomment, idxcomment);
  READ_UINT_FIELD(IndexStmt, index_oid, indexOid, indexOid);
  READ_UINT_FIELD(IndexStmt, old_number, oldNumber, oldNumber);
  READ_UINT_FIELD(IndexStmt, old_create_subid, oldCreateSubid, oldCreateSubid);
  READ_UINT_FIELD(IndexStmt, old_first_relfilelocator_subid, oldFirstRelfilelocatorSubid, oldFirstRelfilelocatorSubid);
  READ_BOOL_FIELD(IndexStmt, unique, unique, unique);
  READ_BOOL_FIELD(IndexStmt, nulls_not_distinct, nulls_not_distinct, nulls_not_distinct);
  READ_BOOL_FIELD(IndexStmt, primary, primary, primary);
  READ_BOOL_FIELD(IndexStmt, isconstraint, isconstraint, isconstraint);
  READ_BOOL_FIELD(IndexStmt, iswithoutoverlaps, iswithoutoverlaps, iswithoutoverlaps);
  READ_BOOL_FIELD(IndexStmt, deferrable, deferrable, deferrable);
  READ_BOOL_FIELD(IndexStmt, initdeferred, initdeferred, initdeferred);
  READ_BOOL_FIELD(IndexStmt, transformed, transformed, transformed);
  READ_BOOL_FIELD(IndexStmt, concurrent, concurrent, concurrent);
  READ_BOOL_FIELD(IndexStmt, if_not_exists, if_not_exists, if_not_exists);
  READ_BOOL_FIELD(IndexStmt, reset_default_tblspc, reset_default_tblspc, reset_default_tblspc);
  return node;
}

static CreateStatsStmt *
_readCreateStatsStmt(const OUT_TYPE(CreateStatsStmt, CreateStatsStmt) msg)
{
  CreateStatsStmt *node = makeNode(CreateStatsStmt);
  READ_LIST_FIELD(CreateStatsStmt, defnames, defnames, defnames);
  READ_LIST_FIELD(CreateStatsStmt, stat_types, stat_types, stat_types);
  READ_LIST_FIELD(CreateStatsStmt, exprs, exprs, exprs);
  READ_LIST_FIELD(CreateStatsStmt, relations, relations, relations);
  READ_STRING_FIELD(CreateStatsStmt, stxcomment, stxcomment, stxcomment);
  READ_BOOL_FIELD(CreateStatsStmt, transformed, transformed, transformed);
  READ_BOOL_FIELD(CreateStatsStmt, if_not_exists, if_not_exists, if_not_exists);
  return node;
}

static StatsElem *
_readStatsElem(const OUT_TYPE(StatsElem, StatsElem) msg)
{
  StatsElem *node = makeNode(StatsElem);
  READ_STRING_FIELD(StatsElem, name, name, name);
  READ_NODE_PTR_FIELD(StatsElem, expr, expr, expr);
  return node;
}

static AlterStatsStmt *
_readAlterStatsStmt(const OUT_TYPE(AlterStatsStmt, AlterStatsStmt) msg)
{
  AlterStatsStmt *node = makeNode(AlterStatsStmt);
  READ_LIST_FIELD(AlterStatsStmt, defnames, defnames, defnames);
  READ_NODE_PTR_FIELD(AlterStatsStmt, stxstattarget, stxstattarget, stxstattarget);
  READ_BOOL_FIELD(AlterStatsStmt, missing_ok, missing_ok, missing_ok);
  return node;
}

static CreateFunctionStmt *
_readCreateFunctionStmt(const OUT_TYPE(CreateFunctionStmt, CreateFunctionStmt) msg)
{
  CreateFunctionStmt *node = makeNode(CreateFunctionStmt);
  READ_BOOL_FIELD(CreateFunctionStmt, is_procedure, is_procedure, is_procedure);
  READ_BOOL_FIELD(CreateFunctionStmt, replace, replace, replace);
  READ_LIST_FIELD(CreateFunctionStmt, funcname, funcname, funcname);
  READ_LIST_FIELD(CreateFunctionStmt, parameters, parameters, parameters);
  READ_SPECIFIC_NODE_PTR_FIELD(CreateFunctionStmt, TypeName, type_name, return_type, returnType, returnType);
  READ_LIST_FIELD(CreateFunctionStmt, options, options, options);
  READ_NODE_PTR_FIELD(CreateFunctionStmt, sql_body, sql_body, sql_body);
  return node;
}

static FunctionParameter *
_readFunctionParameter(const OUT_TYPE(FunctionParameter, FunctionParameter) msg)
{
  FunctionParameter *node = makeNode(FunctionParameter);
  READ_STRING_FIELD(FunctionParameter, name, name, name);
  READ_SPECIFIC_NODE_PTR_FIELD(FunctionParameter, TypeName, type_name, arg_type, argType, argType);
  READ_ENUM_FIELD(FunctionParameter, FunctionParameterMode, mode, mode, mode);
  READ_NODE_PTR_FIELD(FunctionParameter, defexpr, defexpr, defexpr);
  READ_INT_FIELD(FunctionParameter, location, location, location);
  return node;
}

static AlterFunctionStmt *
_readAlterFunctionStmt(const OUT_TYPE(AlterFunctionStmt, AlterFunctionStmt) msg)
{
  AlterFunctionStmt *node = makeNode(AlterFunctionStmt);
  READ_ENUM_FIELD(AlterFunctionStmt, ObjectType, objtype, objtype, objtype);
  READ_SPECIFIC_NODE_PTR_FIELD(AlterFunctionStmt, ObjectWithArgs, object_with_args, func, func, func);
  READ_LIST_FIELD(AlterFunctionStmt, actions, actions, actions);
  return node;
}

static DoStmt *
_readDoStmt(const OUT_TYPE(DoStmt, DoStmt) msg)
{
  DoStmt *node = makeNode(DoStmt);
  READ_LIST_FIELD(DoStmt, args, args, args);
  return node;
}

static InlineCodeBlock *
_readInlineCodeBlock(const OUT_TYPE(InlineCodeBlock, InlineCodeBlock) msg)
{
  InlineCodeBlock *node = makeNode(InlineCodeBlock);
  READ_STRING_FIELD(InlineCodeBlock, source_text, source_text, source_text);
  READ_UINT_FIELD(InlineCodeBlock, lang_oid, langOid, langOid);
  READ_BOOL_FIELD(InlineCodeBlock, lang_is_trusted, langIsTrusted, langIsTrusted);
  READ_BOOL_FIELD(InlineCodeBlock, atomic, atomic, atomic);
  return node;
}

static CallStmt *
_readCallStmt(const OUT_TYPE(CallStmt, CallStmt) msg)
{
  CallStmt *node = makeNode(CallStmt);
  READ_SPECIFIC_NODE_PTR_FIELD(CallStmt, FuncCall, func_call, funccall, funccall, funccall);
  READ_SPECIFIC_NODE_PTR_FIELD(CallStmt, FuncExpr, func_expr, funcexpr, funcexpr, funcexpr);
  READ_LIST_FIELD(CallStmt, outargs, outargs, outargs);
  return node;
}

static CallContext *
_readCallContext(const OUT_TYPE(CallContext, CallContext) msg)
{
  CallContext *node = makeNode(CallContext);
  READ_BOOL_FIELD(CallContext, atomic, atomic, atomic);
  return node;
}

static RenameStmt *
_readRenameStmt(const OUT_TYPE(RenameStmt, RenameStmt) msg)
{
  RenameStmt *node = makeNode(RenameStmt);
  READ_ENUM_FIELD(RenameStmt, ObjectType, rename_type, renameType, renameType);
  READ_ENUM_FIELD(RenameStmt, ObjectType, relation_type, relationType, relationType);
  READ_SPECIFIC_NODE_PTR_FIELD(RenameStmt, RangeVar, range_var, relation, relation, relation);
  READ_NODE_PTR_FIELD(RenameStmt, object, object, object);
  READ_STRING_FIELD(RenameStmt, subname, subname, subname);
  READ_STRING_FIELD(RenameStmt, newname, newname, newname);
  READ_ENUM_FIELD(RenameStmt, DropBehavior, behavior, behavior, behavior);
  READ_BOOL_FIELD(RenameStmt, missing_ok, missing_ok, missing_ok);
  return node;
}

static AlterObjectDependsStmt *
_readAlterObjectDependsStmt(const OUT_TYPE(AlterObjectDependsStmt, AlterObjectDependsStmt) msg)
{
  AlterObjectDependsStmt *node = makeNode(AlterObjectDependsStmt);
  READ_ENUM_FIELD(AlterObjectDependsStmt, ObjectType, object_type, objectType, objectType);
  READ_SPECIFIC_NODE_PTR_FIELD(AlterObjectDependsStmt, RangeVar, range_var, relation, relation, relation);
  READ_NODE_PTR_FIELD(AlterObjectDependsStmt, object, object, object);
  READ_SPECIFIC_NODE_PTR_FIELD(AlterObjectDependsStmt, String, string, extname, extname, extname);
  READ_BOOL_FIELD(AlterObjectDependsStmt, remove, remove, remove);
  return node;
}

static AlterObjectSchemaStmt *
_readAlterObjectSchemaStmt(const OUT_TYPE(AlterObjectSchemaStmt, AlterObjectSchemaStmt) msg)
{
  AlterObjectSchemaStmt *node = makeNode(AlterObjectSchemaStmt);
  READ_ENUM_FIELD(AlterObjectSchemaStmt, ObjectType, object_type, objectType, objectType);
  READ_SPECIFIC_NODE_PTR_FIELD(AlterObjectSchemaStmt, RangeVar, range_var, relation, relation, relation);
  READ_NODE_PTR_FIELD(AlterObjectSchemaStmt, object, object, object);
  READ_STRING_FIELD(AlterObjectSchemaStmt, newschema, newschema, newschema);
  READ_BOOL_FIELD(AlterObjectSchemaStmt, missing_ok, missing_ok, missing_ok);
  return node;
}

static AlterOwnerStmt *
_readAlterOwnerStmt(const OUT_TYPE(AlterOwnerStmt, AlterOwnerStmt) msg)
{
  AlterOwnerStmt *node = makeNode(AlterOwnerStmt);
  READ_ENUM_FIELD(AlterOwnerStmt, ObjectType, object_type, objectType, objectType);
  READ_SPECIFIC_NODE_PTR_FIELD(AlterOwnerStmt, RangeVar, range_var, relation, relation, relation);
  READ_NODE_PTR_FIELD(AlterOwnerStmt, object, object, object);
  READ_SPECIFIC_NODE_PTR_FIELD(AlterOwnerStmt, RoleSpec, role_spec, newowner, newowner, newowner);
  return node;
}

static AlterOperatorStmt *
_readAlterOperatorStmt(const OUT_TYPE(AlterOperatorStmt, AlterOperatorStmt) msg)
{
  AlterOperatorStmt *node = makeNode(AlterOperatorStmt);
  READ_SPECIFIC_NODE_PTR_FIELD(AlterOperatorStmt, ObjectWithArgs, object_with_args, opername, opername, opername);
  READ_LIST_FIELD(AlterOperatorStmt, options, options, options);
  return node;
}

static AlterTypeStmt *
_readAlterTypeStmt(const OUT_TYPE(AlterTypeStmt, AlterTypeStmt) msg)
{
  AlterTypeStmt *node = makeNode(AlterTypeStmt);
  READ_LIST_FIELD(AlterTypeStmt, type_name, typeName, typeName);
  READ_LIST_FIELD(AlterTypeStmt, options, options, options);
  return node;
}

static RuleStmt *
_readRuleStmt(const OUT_TYPE(RuleStmt, RuleStmt) msg)
{
  RuleStmt *node = makeNode(RuleStmt);
  READ_SPECIFIC_NODE_PTR_FIELD(RuleStmt, RangeVar, range_var, relation, relation, relation);
  READ_STRING_FIELD(RuleStmt, rulename, rulename, rulename);
  READ_NODE_PTR_FIELD(RuleStmt, where_clause, whereClause, whereClause);
  READ_ENUM_FIELD(RuleStmt, CmdType, event, event, event);
  READ_BOOL_FIELD(RuleStmt, instead, instead, instead);
  READ_LIST_FIELD(RuleStmt, actions, actions, actions);
  READ_BOOL_FIELD(RuleStmt, replace, replace, replace);
  return node;
}

static NotifyStmt *
_readNotifyStmt(const OUT_TYPE(NotifyStmt, NotifyStmt) msg)
{
  NotifyStmt *node = makeNode(NotifyStmt);
  READ_STRING_FIELD(NotifyStmt, conditionname, conditionname, conditionname);
  READ_STRING_FIELD(NotifyStmt, payload, payload, payload);
  READ_INT_FIELD(NotifyStmt, payload_location, payload_location, payload_location);
  return node;
}

static ListenStmt *
_readListenStmt(const OUT_TYPE(ListenStmt, ListenStmt) msg)
{
  ListenStmt *node = makeNode(ListenStmt);
  READ_STRING_FIELD(ListenStmt, conditionname, conditionname, conditionname);
  return node;
}

static UnlistenStmt *
_readUnlistenStmt(const OUT_TYPE(UnlistenStmt, UnlistenStmt) msg)
{
  UnlistenStmt *node = makeNode(UnlistenStmt);
  READ_STRING_FIELD(UnlistenStmt, conditionname, conditionname, conditionname);
  return node;
}

static TransactionStmt *
_readTransactionStmt(const OUT_TYPE(TransactionStmt, TransactionStmt) msg)
{
  TransactionStmt *node = makeNode(TransactionStmt);
  READ_ENUM_FIELD(TransactionStmt, TransactionStmtKind, kind, kind, kind);
  READ_LIST_FIELD(TransactionStmt, options, options, options);
  READ_STRING_FIELD(TransactionStmt, savepoint_name, savepoint_name, savepoint_name);
  READ_STRING_FIELD(TransactionStmt, gid, gid, gid);
  READ_BOOL_FIELD(TransactionStmt, chain, chain, chain);
  READ_INT_FIELD(TransactionStmt, location, location, location);
  return node;
}

static CompositeTypeStmt *
_readCompositeTypeStmt(const OUT_TYPE(CompositeTypeStmt, CompositeTypeStmt) msg)
{
  CompositeTypeStmt *node = makeNode(CompositeTypeStmt);
  READ_SPECIFIC_NODE_PTR_FIELD(CompositeTypeStmt, RangeVar, range_var, typevar, typevar, typevar);
  READ_LIST_FIELD(CompositeTypeStmt, coldeflist, coldeflist, coldeflist);
  return node;
}

static CreateEnumStmt *
_readCreateEnumStmt(const OUT_TYPE(CreateEnumStmt, CreateEnumStmt) msg)
{
  CreateEnumStmt *node = makeNode(CreateEnumStmt);
  READ_LIST_FIELD(CreateEnumStmt, type_name, typeName, typeName);
  READ_LIST_FIELD(CreateEnumStmt, vals, vals, vals);
  return node;
}

static CreateRangeStmt *
_readCreateRangeStmt(const OUT_TYPE(CreateRangeStmt, CreateRangeStmt) msg)
{
  CreateRangeStmt *node = makeNode(CreateRangeStmt);
  READ_LIST_FIELD(CreateRangeStmt, type_name, typeName, typeName);
  READ_LIST_FIELD(CreateRangeStmt, params, params, params);
  return node;
}

static AlterEnumStmt *
_readAlterEnumStmt(const OUT_TYPE(AlterEnumStmt, AlterEnumStmt) msg)
{
  AlterEnumStmt *node = makeNode(AlterEnumStmt);
  READ_LIST_FIELD(AlterEnumStmt, type_name, typeName, typeName);
  READ_STRING_FIELD(AlterEnumStmt, old_val, oldVal, oldVal);
  READ_STRING_FIELD(AlterEnumStmt, new_val, newVal, newVal);
  READ_STRING_FIELD(AlterEnumStmt, new_val_neighbor, newValNeighbor, newValNeighbor);
  READ_BOOL_FIELD(AlterEnumStmt, new_val_is_after, newValIsAfter, newValIsAfter);
  READ_BOOL_FIELD(AlterEnumStmt, skip_if_new_val_exists, skipIfNewValExists, skipIfNewValExists);
  return node;
}

static ViewStmt *
_readViewStmt(const OUT_TYPE(ViewStmt, ViewStmt) msg)
{
  ViewStmt *node = makeNode(ViewStmt);
  READ_SPECIFIC_NODE_PTR_FIELD(ViewStmt, RangeVar, range_var, view, view, view);
  READ_LIST_FIELD(ViewStmt, aliases, aliases, aliases);
  READ_NODE_PTR_FIELD(ViewStmt, query, query, query);
  READ_BOOL_FIELD(ViewStmt, replace, replace, replace);
  READ_LIST_FIELD(ViewStmt, options, options, options);
  READ_ENUM_FIELD(ViewStmt, ViewCheckOption, with_check_option, withCheckOption, withCheckOption);
  return node;
}

static LoadStmt *
_readLoadStmt(const OUT_TYPE(LoadStmt, LoadStmt) msg)
{
  LoadStmt *node = makeNode(LoadStmt);
  READ_STRING_FIELD(LoadStmt, filename, filename, filename);
  return node;
}

static CreatedbStmt *
_readCreatedbStmt(const OUT_TYPE(CreatedbStmt, CreatedbStmt) msg)
{
  CreatedbStmt *node = makeNode(CreatedbStmt);
  READ_STRING_FIELD(CreatedbStmt, dbname, dbname, dbname);
  READ_LIST_FIELD(CreatedbStmt, options, options, options);
  return node;
}

static AlterDatabaseStmt *
_readAlterDatabaseStmt(const OUT_TYPE(AlterDatabaseStmt, AlterDatabaseStmt) msg)
{
  AlterDatabaseStmt *node = makeNode(AlterDatabaseStmt);
  READ_STRING_FIELD(AlterDatabaseStmt, dbname, dbname, dbname);
  READ_LIST_FIELD(AlterDatabaseStmt, options, options, options);
  return node;
}

static AlterDatabaseRefreshCollStmt *
_readAlterDatabaseRefreshCollStmt(const OUT_TYPE(AlterDatabaseRefreshCollStmt, AlterDatabaseRefreshCollStmt) msg)
{
  AlterDatabaseRefreshCollStmt *node = makeNode(AlterDatabaseRefreshCollStmt);
  READ_STRING_FIELD(AlterDatabaseRefreshCollStmt, dbname, dbname, dbname);
  return node;
}

static AlterDatabaseSetStmt *
_readAlterDatabaseSetStmt(const OUT_TYPE(AlterDatabaseSetStmt, AlterDatabaseSetStmt) msg)
{
  AlterDatabaseSetStmt *node = makeNode(AlterDatabaseSetStmt);
  READ_STRING_FIELD(AlterDatabaseSetStmt, dbname, dbname, dbname);
  READ_SPECIFIC_NODE_PTR_FIELD(AlterDatabaseSetStmt, VariableSetStmt, variable_set_stmt, setstmt, setstmt, setstmt);
  return node;
}

static DropdbStmt *
_readDropdbStmt(const OUT_TYPE(DropdbStmt, DropdbStmt) msg)
{
  DropdbStmt *node = makeNode(DropdbStmt);
  READ_STRING_FIELD(DropdbStmt, dbname, dbname, dbname);
  READ_BOOL_FIELD(DropdbStmt, missing_ok, missing_ok, missing_ok);
  READ_LIST_FIELD(DropdbStmt, options, options, options);
  return node;
}

static AlterSystemStmt *
_readAlterSystemStmt(const OUT_TYPE(AlterSystemStmt, AlterSystemStmt) msg)
{
  AlterSystemStmt *node = makeNode(AlterSystemStmt);
  READ_SPECIFIC_NODE_PTR_FIELD(AlterSystemStmt, VariableSetStmt, variable_set_stmt, setstmt, setstmt, setstmt);
  return node;
}

static ClusterStmt *
_readClusterStmt(const OUT_TYPE(ClusterStmt, ClusterStmt) msg)
{
  ClusterStmt *node = makeNode(ClusterStmt);
  READ_SPECIFIC_NODE_PTR_FIELD(ClusterStmt, RangeVar, range_var, relation, relation, relation);
  READ_STRING_FIELD(ClusterStmt, indexname, indexname, indexname);
  READ_LIST_FIELD(ClusterStmt, params, params, params);
  return node;
}

static VacuumStmt *
_readVacuumStmt(const OUT_TYPE(VacuumStmt, VacuumStmt) msg)
{
  VacuumStmt *node = makeNode(VacuumStmt);
  READ_LIST_FIELD(VacuumStmt, options, options, options);
  READ_LIST_FIELD(VacuumStmt, rels, rels, rels);
  READ_BOOL_FIELD(VacuumStmt, is_vacuumcmd, is_vacuumcmd, is_vacuumcmd);
  return node;
}

static VacuumRelation *
_readVacuumRelation(const OUT_TYPE(VacuumRelation, VacuumRelation) msg)
{
  VacuumRelation *node = makeNode(VacuumRelation);
  READ_SPECIFIC_NODE_PTR_FIELD(VacuumRelation, RangeVar, range_var, relation, relation, relation);
  READ_UINT_FIELD(VacuumRelation, oid, oid, oid);
  READ_LIST_FIELD(VacuumRelation, va_cols, va_cols, va_cols);
  return node;
}

static ExplainStmt *
_readExplainStmt(const OUT_TYPE(ExplainStmt, ExplainStmt) msg)
{
  ExplainStmt *node = makeNode(ExplainStmt);
  READ_NODE_PTR_FIELD(ExplainStmt, query, query, query);
  READ_LIST_FIELD(ExplainStmt, options, options, options);
  return node;
}

static CreateTableAsStmt *
_readCreateTableAsStmt(const OUT_TYPE(CreateTableAsStmt, CreateTableAsStmt) msg)
{
  CreateTableAsStmt *node = makeNode(CreateTableAsStmt);
  READ_NODE_PTR_FIELD(CreateTableAsStmt, query, query, query);
  READ_SPECIFIC_NODE_PTR_FIELD(CreateTableAsStmt, IntoClause, into_clause, into, into, into);
  READ_ENUM_FIELD(CreateTableAsStmt, ObjectType, objtype, objtype, objtype);
  READ_BOOL_FIELD(CreateTableAsStmt, is_select_into, is_select_into, is_select_into);
  READ_BOOL_FIELD(CreateTableAsStmt, if_not_exists, if_not_exists, if_not_exists);
  return node;
}

static RefreshMatViewStmt *
_readRefreshMatViewStmt(const OUT_TYPE(RefreshMatViewStmt, RefreshMatViewStmt) msg)
{
  RefreshMatViewStmt *node = makeNode(RefreshMatViewStmt);
  READ_BOOL_FIELD(RefreshMatViewStmt, concurrent, concurrent, concurrent);
  READ_BOOL_FIELD(RefreshMatViewStmt, skip_data, skipData, skipData);
  READ_SPECIFIC_NODE_PTR_FIELD(RefreshMatViewStmt, RangeVar, range_var, relation, relation, relation);
  return node;
}

static CheckPointStmt *
_readCheckPointStmt(const OUT_TYPE(CheckPointStmt, CheckPointStmt) msg)
{
  CheckPointStmt *node = makeNode(CheckPointStmt);
  return node;
}

static DiscardStmt *
_readDiscardStmt(const OUT_TYPE(DiscardStmt, DiscardStmt) msg)
{
  DiscardStmt *node = makeNode(DiscardStmt);
  READ_ENUM_FIELD(DiscardStmt, DiscardMode, target, target, target);
  return node;
}

static LockStmt *
_readLockStmt(const OUT_TYPE(LockStmt, LockStmt) msg)
{
  LockStmt *node = makeNode(LockStmt);
  READ_LIST_FIELD(LockStmt, relations, relations, relations);
  READ_INT_FIELD(LockStmt, mode, mode, mode);
  READ_BOOL_FIELD(LockStmt, nowait, nowait, nowait);
  return node;
}

static ConstraintsSetStmt *
_readConstraintsSetStmt(const OUT_TYPE(ConstraintsSetStmt, ConstraintsSetStmt) msg)
{
  ConstraintsSetStmt *node = makeNode(ConstraintsSetStmt);
  READ_LIST_FIELD(ConstraintsSetStmt, constraints, constraints, constraints);
  READ_BOOL_FIELD(ConstraintsSetStmt, deferred, deferred, deferred);
  return node;
}

static ReindexStmt *
_readReindexStmt(const OUT_TYPE(ReindexStmt, ReindexStmt) msg)
{
  ReindexStmt *node = makeNode(ReindexStmt);
  READ_ENUM_FIELD(ReindexStmt, ReindexObjectType, kind, kind, kind);
  READ_SPECIFIC_NODE_PTR_FIELD(ReindexStmt, RangeVar, range_var, relation, relation, relation);
  READ_STRING_FIELD(ReindexStmt, name, name, name);
  READ_LIST_FIELD(ReindexStmt, params, params, params);
  return node;
}

static CreateConversionStmt *
_readCreateConversionStmt(const OUT_TYPE(CreateConversionStmt, CreateConversionStmt) msg)
{
  CreateConversionStmt *node = makeNode(CreateConversionStmt);
  READ_LIST_FIELD(CreateConversionStmt, conversion_name, conversion_name, conversion_name);
  READ_STRING_FIELD(CreateConversionStmt, for_encoding_name, for_encoding_name, for_encoding_name);
  READ_STRING_FIELD(CreateConversionStmt, to_encoding_name, to_encoding_name, to_encoding_name);
  READ_LIST_FIELD(CreateConversionStmt, func_name, func_name, func_name);
  READ_BOOL_FIELD(CreateConversionStmt, def, def, def);
  return node;
}

static CreateCastStmt *
_readCreateCastStmt(const OUT_TYPE(CreateCastStmt, CreateCastStmt) msg)
{
  CreateCastStmt *node = makeNode(CreateCastStmt);
  READ_SPECIFIC_NODE_PTR_FIELD(CreateCastStmt, TypeName, type_name, sourcetype, sourcetype, sourcetype);
  READ_SPECIFIC_NODE_PTR_FIELD(CreateCastStmt, TypeName, type_name, targettype, targettype, targettype);
  READ_SPECIFIC_NODE_PTR_FIELD(CreateCastStmt, ObjectWithArgs, object_with_args, func, func, func);
  READ_ENUM_FIELD(CreateCastStmt, CoercionContext, context, context, context);
  READ_BOOL_FIELD(CreateCastStmt, inout, inout, inout);
  return node;
}

static CreateTransformStmt *
_readCreateTransformStmt(const OUT_TYPE(CreateTransformStmt, CreateTransformStmt) msg)
{
  CreateTransformStmt *node = makeNode(CreateTransformStmt);
  READ_BOOL_FIELD(CreateTransformStmt, replace, replace, replace);
  READ_SPECIFIC_NODE_PTR_FIELD(CreateTransformStmt, TypeName, type_name, type_name, type_name, type_name);
  READ_STRING_FIELD(CreateTransformStmt, lang, lang, lang);
  READ_SPECIFIC_NODE_PTR_FIELD(CreateTransformStmt, ObjectWithArgs, object_with_args, fromsql, fromsql, fromsql);
  READ_SPECIFIC_NODE_PTR_FIELD(CreateTransformStmt, ObjectWithArgs, object_with_args, tosql, tosql, tosql);
  return node;
}

static PrepareStmt *
_readPrepareStmt(const OUT_TYPE(PrepareStmt, PrepareStmt) msg)
{
  PrepareStmt *node = makeNode(PrepareStmt);
  READ_STRING_FIELD(PrepareStmt, name, name, name);
  READ_LIST_FIELD(PrepareStmt, argtypes, argtypes, argtypes);
  READ_NODE_PTR_FIELD(PrepareStmt, query, query, query);
  return node;
}

static ExecuteStmt *
_readExecuteStmt(const OUT_TYPE(ExecuteStmt, ExecuteStmt) msg)
{
  ExecuteStmt *node = makeNode(ExecuteStmt);
  READ_STRING_FIELD(ExecuteStmt, name, name, name);
  READ_LIST_FIELD(ExecuteStmt, params, params, params);
  return node;
}

static DeallocateStmt *
_readDeallocateStmt(const OUT_TYPE(DeallocateStmt, DeallocateStmt) msg)
{
  DeallocateStmt *node = makeNode(DeallocateStmt);
  READ_STRING_FIELD(DeallocateStmt, name, name, name);
  READ_BOOL_FIELD(DeallocateStmt, isall, isall, isall);
  READ_INT_FIELD(DeallocateStmt, location, location, location);
  return node;
}

static DropOwnedStmt *
_readDropOwnedStmt(const OUT_TYPE(DropOwnedStmt, DropOwnedStmt) msg)
{
  DropOwnedStmt *node = makeNode(DropOwnedStmt);
  READ_LIST_FIELD(DropOwnedStmt, roles, roles, roles);
  READ_ENUM_FIELD(DropOwnedStmt, DropBehavior, behavior, behavior, behavior);
  return node;
}

static ReassignOwnedStmt *
_readReassignOwnedStmt(const OUT_TYPE(ReassignOwnedStmt, ReassignOwnedStmt) msg)
{
  ReassignOwnedStmt *node = makeNode(ReassignOwnedStmt);
  READ_LIST_FIELD(ReassignOwnedStmt, roles, roles, roles);
  READ_SPECIFIC_NODE_PTR_FIELD(ReassignOwnedStmt, RoleSpec, role_spec, newrole, newrole, newrole);
  return node;
}

static AlterTSDictionaryStmt *
_readAlterTSDictionaryStmt(const OUT_TYPE(AlterTSDictionaryStmt, AlterTSDictionaryStmt) msg)
{
  AlterTSDictionaryStmt *node = makeNode(AlterTSDictionaryStmt);
  READ_LIST_FIELD(AlterTSDictionaryStmt, dictname, dictname, dictname);
  READ_LIST_FIELD(AlterTSDictionaryStmt, options, options, options);
  return node;
}

static AlterTSConfigurationStmt *
_readAlterTSConfigurationStmt(const OUT_TYPE(AlterTSConfigurationStmt, AlterTSConfigurationStmt) msg)
{
  AlterTSConfigurationStmt *node = makeNode(AlterTSConfigurationStmt);
  READ_ENUM_FIELD(AlterTSConfigurationStmt, AlterTSConfigType, kind, kind, kind);
  READ_LIST_FIELD(AlterTSConfigurationStmt, cfgname, cfgname, cfgname);
  READ_LIST_FIELD(AlterTSConfigurationStmt, tokentype, tokentype, tokentype);
  READ_LIST_FIELD(AlterTSConfigurationStmt, dicts, dicts, dicts);
  READ_BOOL_FIELD(AlterTSConfigurationStmt, override, override, override);
  READ_BOOL_FIELD(AlterTSConfigurationStmt, replace, replace, replace);
  READ_BOOL_FIELD(AlterTSConfigurationStmt, missing_ok, missing_ok, missing_ok);
  return node;
}

static PublicationTable *
_readPublicationTable(const OUT_TYPE(PublicationTable, PublicationTable) msg)
{
  PublicationTable *node = makeNode(PublicationTable);
  READ_SPECIFIC_NODE_PTR_FIELD(PublicationTable, RangeVar, range_var, relation, relation, relation);
  READ_NODE_PTR_FIELD(PublicationTable, where_clause, whereClause, whereClause);
  READ_LIST_FIELD(PublicationTable, columns, columns, columns);
  return node;
}

static PublicationObjSpec *
_readPublicationObjSpec(const OUT_TYPE(PublicationObjSpec, PublicationObjSpec) msg)
{
  PublicationObjSpec *node = makeNode(PublicationObjSpec);
  READ_ENUM_FIELD(PublicationObjSpec, PublicationObjSpecType, pubobjtype, pubobjtype, pubobjtype);
  READ_STRING_FIELD(PublicationObjSpec, name, name, name);
  READ_SPECIFIC_NODE_PTR_FIELD(PublicationObjSpec, PublicationTable, publication_table, pubtable, pubtable, pubtable);
  READ_INT_FIELD(PublicationObjSpec, location, location, location);
  return node;
}

static CreatePublicationStmt *
_readCreatePublicationStmt(const OUT_TYPE(CreatePublicationStmt, CreatePublicationStmt) msg)
{
  CreatePublicationStmt *node = makeNode(CreatePublicationStmt);
  READ_STRING_FIELD(CreatePublicationStmt, pubname, pubname, pubname);
  READ_LIST_FIELD(CreatePublicationStmt, options, options, options);
  READ_LIST_FIELD(CreatePublicationStmt, pubobjects, pubobjects, pubobjects);
  READ_BOOL_FIELD(CreatePublicationStmt, for_all_tables, for_all_tables, for_all_tables);
  return node;
}

static AlterPublicationStmt *
_readAlterPublicationStmt(const OUT_TYPE(AlterPublicationStmt, AlterPublicationStmt) msg)
{
  AlterPublicationStmt *node = makeNode(AlterPublicationStmt);
  READ_STRING_FIELD(AlterPublicationStmt, pubname, pubname, pubname);
  READ_LIST_FIELD(AlterPublicationStmt, options, options, options);
  READ_LIST_FIELD(AlterPublicationStmt, pubobjects, pubobjects, pubobjects);
  READ_BOOL_FIELD(AlterPublicationStmt, for_all_tables, for_all_tables, for_all_tables);
  READ_ENUM_FIELD(AlterPublicationStmt, AlterPublicationAction, action, action, action);
  return node;
}

static CreateSubscriptionStmt *
_readCreateSubscriptionStmt(const OUT_TYPE(CreateSubscriptionStmt, CreateSubscriptionStmt) msg)
{
  CreateSubscriptionStmt *node = makeNode(CreateSubscriptionStmt);
  READ_STRING_FIELD(CreateSubscriptionStmt, subname, subname, subname);
  READ_STRING_FIELD(CreateSubscriptionStmt, conninfo, conninfo, conninfo);
  READ_LIST_FIELD(CreateSubscriptionStmt, publication, publication, publication);
  READ_LIST_FIELD(CreateSubscriptionStmt, options, options, options);
  READ_INT_FIELD(CreateSubscriptionStmt, conninfo_location, conninfo_location, conninfo_location);
  return node;
}

static AlterSubscriptionStmt *
_readAlterSubscriptionStmt(const OUT_TYPE(AlterSubscriptionStmt, AlterSubscriptionStmt) msg)
{
  AlterSubscriptionStmt *node = makeNode(AlterSubscriptionStmt);
  READ_ENUM_FIELD(AlterSubscriptionStmt, AlterSubscriptionType, kind, kind, kind);
  READ_STRING_FIELD(AlterSubscriptionStmt, subname, subname, subname);
  READ_STRING_FIELD(AlterSubscriptionStmt, conninfo, conninfo, conninfo);
  READ_LIST_FIELD(AlterSubscriptionStmt, publication, publication, publication);
  READ_LIST_FIELD(AlterSubscriptionStmt, options, options, options);
  READ_INT_FIELD(AlterSubscriptionStmt, conninfo_location, conninfo_location, conninfo_location);
  return node;
}

static DropSubscriptionStmt *
_readDropSubscriptionStmt(const OUT_TYPE(DropSubscriptionStmt, DropSubscriptionStmt) msg)
{
  DropSubscriptionStmt *node = makeNode(DropSubscriptionStmt);
  READ_STRING_FIELD(DropSubscriptionStmt, subname, subname, subname);
  READ_BOOL_FIELD(DropSubscriptionStmt, missing_ok, missing_ok, missing_ok);
  READ_ENUM_FIELD(DropSubscriptionStmt, DropBehavior, behavior, behavior, behavior);
  return node;
}