use crate::*;
#[derive(Debug, Copy, Clone)]
pub enum NodeMut {
Alias(*mut protobuf::Alias),
RangeVar(*mut protobuf::RangeVar),
TableFunc(*mut protobuf::TableFunc),
Var(*mut protobuf::Var),
Param(*mut protobuf::Param),
Aggref(*mut protobuf::Aggref),
GroupingFunc(*mut protobuf::GroupingFunc),
WindowFunc(*mut protobuf::WindowFunc),
SubscriptingRef(*mut protobuf::SubscriptingRef),
FuncExpr(*mut protobuf::FuncExpr),
NamedArgExpr(*mut protobuf::NamedArgExpr),
OpExpr(*mut protobuf::OpExpr),
DistinctExpr(*mut protobuf::DistinctExpr),
NullIfExpr(*mut protobuf::NullIfExpr),
ScalarArrayOpExpr(*mut protobuf::ScalarArrayOpExpr),
BoolExpr(*mut protobuf::BoolExpr),
SubLink(*mut protobuf::SubLink),
SubPlan(*mut protobuf::SubPlan),
AlternativeSubPlan(*mut protobuf::AlternativeSubPlan),
FieldSelect(*mut protobuf::FieldSelect),
FieldStore(*mut protobuf::FieldStore),
RelabelType(*mut protobuf::RelabelType),
CoerceViaIo(*mut protobuf::CoerceViaIo),
ArrayCoerceExpr(*mut protobuf::ArrayCoerceExpr),
ConvertRowtypeExpr(*mut protobuf::ConvertRowtypeExpr),
CollateExpr(*mut protobuf::CollateExpr),
CaseExpr(*mut protobuf::CaseExpr),
CaseWhen(*mut protobuf::CaseWhen),
CaseTestExpr(*mut protobuf::CaseTestExpr),
ArrayExpr(*mut protobuf::ArrayExpr),
RowExpr(*mut protobuf::RowExpr),
RowCompareExpr(*mut protobuf::RowCompareExpr),
CoalesceExpr(*mut protobuf::CoalesceExpr),
MinMaxExpr(*mut protobuf::MinMaxExpr),
SqlvalueFunction(*mut protobuf::SqlValueFunction),
XmlExpr(*mut protobuf::XmlExpr),
NullTest(*mut protobuf::NullTest),
BooleanTest(*mut protobuf::BooleanTest),
CoerceToDomain(*mut protobuf::CoerceToDomain),
CoerceToDomainValue(*mut protobuf::CoerceToDomainValue),
SetToDefault(*mut protobuf::SetToDefault),
CurrentOfExpr(*mut protobuf::CurrentOfExpr),
NextValueExpr(*mut protobuf::NextValueExpr),
InferenceElem(*mut protobuf::InferenceElem),
TargetEntry(*mut protobuf::TargetEntry),
RangeTblRef(*mut protobuf::RangeTblRef),
JoinExpr(*mut protobuf::JoinExpr),
FromExpr(*mut protobuf::FromExpr),
OnConflictExpr(*mut protobuf::OnConflictExpr),
IntoClause(*mut protobuf::IntoClause),
RawStmt(*mut protobuf::RawStmt),
Query(*mut protobuf::Query),
InsertStmt(*mut protobuf::InsertStmt),
DeleteStmt(*mut protobuf::DeleteStmt),
UpdateStmt(*mut protobuf::UpdateStmt),
SelectStmt(*mut protobuf::SelectStmt),
AlterTableStmt(*mut protobuf::AlterTableStmt),
AlterTableCmd(*mut protobuf::AlterTableCmd),
AlterDomainStmt(*mut protobuf::AlterDomainStmt),
SetOperationStmt(*mut protobuf::SetOperationStmt),
GrantStmt(*mut protobuf::GrantStmt),
GrantRoleStmt(*mut protobuf::GrantRoleStmt),
AlterDefaultPrivilegesStmt(*mut protobuf::AlterDefaultPrivilegesStmt),
ClosePortalStmt(*mut protobuf::ClosePortalStmt),
ClusterStmt(*mut protobuf::ClusterStmt),
CopyStmt(*mut protobuf::CopyStmt),
CreateStmt(*mut protobuf::CreateStmt),
DefineStmt(*mut protobuf::DefineStmt),
DropStmt(*mut protobuf::DropStmt),
TruncateStmt(*mut protobuf::TruncateStmt),
CommentStmt(*mut protobuf::CommentStmt),
FetchStmt(*mut protobuf::FetchStmt),
IndexStmt(*mut protobuf::IndexStmt),
CreateFunctionStmt(*mut protobuf::CreateFunctionStmt),
AlterFunctionStmt(*mut protobuf::AlterFunctionStmt),
DoStmt(*mut protobuf::DoStmt),
RenameStmt(*mut protobuf::RenameStmt),
RuleStmt(*mut protobuf::RuleStmt),
NotifyStmt(*mut protobuf::NotifyStmt),
ListenStmt(*mut protobuf::ListenStmt),
UnlistenStmt(*mut protobuf::UnlistenStmt),
TransactionStmt(*mut protobuf::TransactionStmt),
ViewStmt(*mut protobuf::ViewStmt),
LoadStmt(*mut protobuf::LoadStmt),
CreateDomainStmt(*mut protobuf::CreateDomainStmt),
CreatedbStmt(*mut protobuf::CreatedbStmt),
DropdbStmt(*mut protobuf::DropdbStmt),
VacuumStmt(*mut protobuf::VacuumStmt),
ExplainStmt(*mut protobuf::ExplainStmt),
CreateTableAsStmt(*mut protobuf::CreateTableAsStmt),
CreateSeqStmt(*mut protobuf::CreateSeqStmt),
AlterSeqStmt(*mut protobuf::AlterSeqStmt),
VariableSetStmt(*mut protobuf::VariableSetStmt),
VariableShowStmt(*mut protobuf::VariableShowStmt),
DiscardStmt(*mut protobuf::DiscardStmt),
CreateTrigStmt(*mut protobuf::CreateTrigStmt),
CreatePlangStmt(*mut protobuf::CreatePLangStmt),
CreateRoleStmt(*mut protobuf::CreateRoleStmt),
AlterRoleStmt(*mut protobuf::AlterRoleStmt),
DropRoleStmt(*mut protobuf::DropRoleStmt),
LockStmt(*mut protobuf::LockStmt),
ConstraintsSetStmt(*mut protobuf::ConstraintsSetStmt),
ReindexStmt(*mut protobuf::ReindexStmt),
CheckPointStmt(*mut protobuf::CheckPointStmt),
CreateSchemaStmt(*mut protobuf::CreateSchemaStmt),
AlterDatabaseStmt(*mut protobuf::AlterDatabaseStmt),
AlterDatabaseSetStmt(*mut protobuf::AlterDatabaseSetStmt),
AlterRoleSetStmt(*mut protobuf::AlterRoleSetStmt),
CreateConversionStmt(*mut protobuf::CreateConversionStmt),
CreateCastStmt(*mut protobuf::CreateCastStmt),
CreateOpClassStmt(*mut protobuf::CreateOpClassStmt),
CreateOpFamilyStmt(*mut protobuf::CreateOpFamilyStmt),
AlterOpFamilyStmt(*mut protobuf::AlterOpFamilyStmt),
PrepareStmt(*mut protobuf::PrepareStmt),
ExecuteStmt(*mut protobuf::ExecuteStmt),
DeallocateStmt(*mut protobuf::DeallocateStmt),
DeclareCursorStmt(*mut protobuf::DeclareCursorStmt),
CreateTableSpaceStmt(*mut protobuf::CreateTableSpaceStmt),
DropTableSpaceStmt(*mut protobuf::DropTableSpaceStmt),
AlterObjectDependsStmt(*mut protobuf::AlterObjectDependsStmt),
AlterObjectSchemaStmt(*mut protobuf::AlterObjectSchemaStmt),
AlterOwnerStmt(*mut protobuf::AlterOwnerStmt),
AlterOperatorStmt(*mut protobuf::AlterOperatorStmt),
AlterTypeStmt(*mut protobuf::AlterTypeStmt),
DropOwnedStmt(*mut protobuf::DropOwnedStmt),
ReassignOwnedStmt(*mut protobuf::ReassignOwnedStmt),
CompositeTypeStmt(*mut protobuf::CompositeTypeStmt),
CreateEnumStmt(*mut protobuf::CreateEnumStmt),
CreateRangeStmt(*mut protobuf::CreateRangeStmt),
AlterEnumStmt(*mut protobuf::AlterEnumStmt),
AlterTsdictionaryStmt(*mut protobuf::AlterTsDictionaryStmt),
AlterTsconfigurationStmt(*mut protobuf::AlterTsConfigurationStmt),
CreateFdwStmt(*mut protobuf::CreateFdwStmt),
AlterFdwStmt(*mut protobuf::AlterFdwStmt),
CreateForeignServerStmt(*mut protobuf::CreateForeignServerStmt),
AlterForeignServerStmt(*mut protobuf::AlterForeignServerStmt),
CreateUserMappingStmt(*mut protobuf::CreateUserMappingStmt),
AlterUserMappingStmt(*mut protobuf::AlterUserMappingStmt),
DropUserMappingStmt(*mut protobuf::DropUserMappingStmt),
AlterTableSpaceOptionsStmt(*mut protobuf::AlterTableSpaceOptionsStmt),
AlterTableMoveAllStmt(*mut protobuf::AlterTableMoveAllStmt),
SecLabelStmt(*mut protobuf::SecLabelStmt),
CreateForeignTableStmt(*mut protobuf::CreateForeignTableStmt),
ImportForeignSchemaStmt(*mut protobuf::ImportForeignSchemaStmt),
CreateExtensionStmt(*mut protobuf::CreateExtensionStmt),
AlterExtensionStmt(*mut protobuf::AlterExtensionStmt),
AlterExtensionContentsStmt(*mut protobuf::AlterExtensionContentsStmt),
CreateEventTrigStmt(*mut protobuf::CreateEventTrigStmt),
AlterEventTrigStmt(*mut protobuf::AlterEventTrigStmt),
RefreshMatViewStmt(*mut protobuf::RefreshMatViewStmt),
ReplicaIdentityStmt(*mut protobuf::ReplicaIdentityStmt),
AlterSystemStmt(*mut protobuf::AlterSystemStmt),
CreatePolicyStmt(*mut protobuf::CreatePolicyStmt),
AlterPolicyStmt(*mut protobuf::AlterPolicyStmt),
CreateTransformStmt(*mut protobuf::CreateTransformStmt),
CreateAmStmt(*mut protobuf::CreateAmStmt),
CreatePublicationStmt(*mut protobuf::CreatePublicationStmt),
AlterPublicationStmt(*mut protobuf::AlterPublicationStmt),
CreateSubscriptionStmt(*mut protobuf::CreateSubscriptionStmt),
AlterSubscriptionStmt(*mut protobuf::AlterSubscriptionStmt),
DropSubscriptionStmt(*mut protobuf::DropSubscriptionStmt),
CreateStatsStmt(*mut protobuf::CreateStatsStmt),
AlterCollationStmt(*mut protobuf::AlterCollationStmt),
CallStmt(*mut protobuf::CallStmt),
AlterStatsStmt(*mut protobuf::AlterStatsStmt),
AExpr(*mut protobuf::AExpr),
ColumnRef(*mut protobuf::ColumnRef),
ParamRef(*mut protobuf::ParamRef),
AConst(*mut protobuf::AConst),
FuncCall(*mut protobuf::FuncCall),
AStar(*mut protobuf::AStar),
AIndices(*mut protobuf::AIndices),
AIndirection(*mut protobuf::AIndirection),
AArrayExpr(*mut protobuf::AArrayExpr),
ResTarget(*mut protobuf::ResTarget),
MultiAssignRef(*mut protobuf::MultiAssignRef),
TypeCast(*mut protobuf::TypeCast),
CollateClause(*mut protobuf::CollateClause),
SortBy(*mut protobuf::SortBy),
WindowDef(*mut protobuf::WindowDef),
RangeSubselect(*mut protobuf::RangeSubselect),
RangeFunction(*mut protobuf::RangeFunction),
RangeTableSample(*mut protobuf::RangeTableSample),
RangeTableFunc(*mut protobuf::RangeTableFunc),
RangeTableFuncCol(*mut protobuf::RangeTableFuncCol),
TypeName(*mut protobuf::TypeName),
ColumnDef(*mut protobuf::ColumnDef),
IndexElem(*mut protobuf::IndexElem),
Constraint(*mut protobuf::Constraint),
DefElem(*mut protobuf::DefElem),
RangeTblEntry(*mut protobuf::RangeTblEntry),
RangeTblFunction(*mut protobuf::RangeTblFunction),
TableSampleClause(*mut protobuf::TableSampleClause),
WithCheckOption(*mut protobuf::WithCheckOption),
SortGroupClause(*mut protobuf::SortGroupClause),
GroupingSet(*mut protobuf::GroupingSet),
WindowClause(*mut protobuf::WindowClause),
ObjectWithArgs(*mut protobuf::ObjectWithArgs),
AccessPriv(*mut protobuf::AccessPriv),
CreateOpClassItem(*mut protobuf::CreateOpClassItem),
TableLikeClause(*mut protobuf::TableLikeClause),
FunctionParameter(*mut protobuf::FunctionParameter),
LockingClause(*mut protobuf::LockingClause),
RowMarkClause(*mut protobuf::RowMarkClause),
XmlSerialize(*mut protobuf::XmlSerialize),
WithClause(*mut protobuf::WithClause),
InferClause(*mut protobuf::InferClause),
OnConflictClause(*mut protobuf::OnConflictClause),
CommonTableExpr(*mut protobuf::CommonTableExpr),
RoleSpec(*mut protobuf::RoleSpec),
TriggerTransition(*mut protobuf::TriggerTransition),
PartitionElem(*mut protobuf::PartitionElem),
PartitionSpec(*mut protobuf::PartitionSpec),
PartitionBoundSpec(*mut protobuf::PartitionBoundSpec),
PartitionRangeDatum(*mut protobuf::PartitionRangeDatum),
PartitionCmd(*mut protobuf::PartitionCmd),
VacuumRelation(*mut protobuf::VacuumRelation),
InlineCodeBlock(*mut protobuf::InlineCodeBlock),
CallContext(*mut protobuf::CallContext),
Integer(*mut protobuf::Integer),
Float(*mut protobuf::Float),
Boolean(*mut protobuf::Boolean),
String(*mut protobuf::String),
BitString(*mut protobuf::BitString),
List(*mut protobuf::List),
IntList(*mut protobuf::IntList),
OidList(*mut protobuf::OidList),
MergeStmt(*mut protobuf::MergeStmt),
MergeAction(*mut protobuf::MergeAction),
AlterDatabaseRefreshCollStmt(*mut protobuf::AlterDatabaseRefreshCollStmt),
ReturnStmt(*mut protobuf::ReturnStmt),
PlassignStmt(*mut protobuf::PlAssignStmt),
StatsElem(*mut protobuf::StatsElem),
CtesearchClause(*mut protobuf::CteSearchClause),
CtecycleClause(*mut protobuf::CteCycleClause),
MergeWhenClause(*mut protobuf::MergeWhenClause),
PublicationObjSpec(*mut protobuf::PublicationObjSpec),
PublicationTable(*mut protobuf::PublicationTable),
JsonFormat(*mut protobuf::JsonFormat),
JsonReturning(*mut protobuf::JsonReturning),
JsonValueExpr(*mut protobuf::JsonValueExpr),
JsonConstructorExpr(*mut protobuf::JsonConstructorExpr),
JsonIsPredicate(*mut protobuf::JsonIsPredicate),
JsonOutput(*mut protobuf::JsonOutput),
JsonKeyValue(*mut protobuf::JsonKeyValue),
JsonObjectConstructor(*mut protobuf::JsonObjectConstructor),
JsonArrayConstructor(*mut protobuf::JsonArrayConstructor),
JsonArrayQueryConstructor(*mut protobuf::JsonArrayQueryConstructor),
JsonAggConstructor(*mut protobuf::JsonAggConstructor),
JsonObjectAgg(*mut protobuf::JsonObjectAgg),
JsonArrayAgg(*mut protobuf::JsonArrayAgg),
RtepermissionInfo(*mut protobuf::RtePermissionInfo),
WindowFuncRunCondition(*mut protobuf::WindowFuncRunCondition),
MergeSupportFunc(*mut protobuf::MergeSupportFunc),
JsonBehavior(*mut protobuf::JsonBehavior),
JsonExpr(*mut protobuf::JsonExpr),
JsonTablePath(*mut protobuf::JsonTablePath),
JsonTablePathScan(*mut protobuf::JsonTablePathScan),
JsonTableSiblingJoin(*mut protobuf::JsonTableSiblingJoin),
SinglePartitionSpec(*mut protobuf::SinglePartitionSpec),
JsonArgument(*mut protobuf::JsonArgument),
JsonFuncExpr(*mut protobuf::JsonFuncExpr),
JsonTablePathSpec(*mut protobuf::JsonTablePathSpec),
JsonTable(*mut protobuf::JsonTable),
JsonTableColumn(*mut protobuf::JsonTableColumn),
JsonParseExpr(*mut protobuf::JsonParseExpr),
JsonScalarExpr(*mut protobuf::JsonScalarExpr),
JsonSerializeExpr(*mut protobuf::JsonSerializeExpr),
}
impl NodeMut {
pub fn deparse(&self) -> Result<String> {
crate::deparse(&protobuf::ParseResult {
version: crate::bindings::PG_VERSION_NUM as i32,
stmts: vec![protobuf::RawStmt { stmt: Some(Box::new(Node { node: Some(self.to_enum()?) })), stmt_location: 0, stmt_len: 0 }],
})
}
pub fn to_enum(&self) -> Result<NodeEnum> {
unsafe {
let err = Error::InvalidPointer;
match self {
NodeMut::Alias(n) => Ok(NodeEnum::Alias(n.as_ref().ok_or(err)?.clone())),
NodeMut::RangeVar(n) => Ok(NodeEnum::RangeVar(n.as_ref().ok_or(err)?.clone())),
NodeMut::TableFunc(n) => Ok(NodeEnum::TableFunc(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::Var(n) => Ok(NodeEnum::Var(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::Param(n) => Ok(NodeEnum::Param(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::Aggref(n) => Ok(NodeEnum::Aggref(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::GroupingFunc(n) => Ok(NodeEnum::GroupingFunc(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::WindowFunc(n) => Ok(NodeEnum::WindowFunc(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::SubscriptingRef(n) => Ok(NodeEnum::SubscriptingRef(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::FuncExpr(n) => Ok(NodeEnum::FuncExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::NamedArgExpr(n) => Ok(NodeEnum::NamedArgExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::OpExpr(n) => Ok(NodeEnum::OpExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::DistinctExpr(n) => Ok(NodeEnum::DistinctExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::NullIfExpr(n) => Ok(NodeEnum::NullIfExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::ScalarArrayOpExpr(n) => Ok(NodeEnum::ScalarArrayOpExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::BoolExpr(n) => Ok(NodeEnum::BoolExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::SubLink(n) => Ok(NodeEnum::SubLink(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::SubPlan(n) => Ok(NodeEnum::SubPlan(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::AlternativeSubPlan(n) => Ok(NodeEnum::AlternativeSubPlan(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::FieldSelect(n) => Ok(NodeEnum::FieldSelect(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::FieldStore(n) => Ok(NodeEnum::FieldStore(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::RelabelType(n) => Ok(NodeEnum::RelabelType(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::CoerceViaIo(n) => Ok(NodeEnum::CoerceViaIo(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::ArrayCoerceExpr(n) => Ok(NodeEnum::ArrayCoerceExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::ConvertRowtypeExpr(n) => Ok(NodeEnum::ConvertRowtypeExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::CollateExpr(n) => Ok(NodeEnum::CollateExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::CaseExpr(n) => Ok(NodeEnum::CaseExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::CaseWhen(n) => Ok(NodeEnum::CaseWhen(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::CaseTestExpr(n) => Ok(NodeEnum::CaseTestExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::ArrayExpr(n) => Ok(NodeEnum::ArrayExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::RowExpr(n) => Ok(NodeEnum::RowExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::RowCompareExpr(n) => Ok(NodeEnum::RowCompareExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::CoalesceExpr(n) => Ok(NodeEnum::CoalesceExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::MinMaxExpr(n) => Ok(NodeEnum::MinMaxExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::SqlvalueFunction(n) => Ok(NodeEnum::SqlvalueFunction(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::XmlExpr(n) => Ok(NodeEnum::XmlExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::NullTest(n) => Ok(NodeEnum::NullTest(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::BooleanTest(n) => Ok(NodeEnum::BooleanTest(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::CoerceToDomain(n) => Ok(NodeEnum::CoerceToDomain(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::CoerceToDomainValue(n) => Ok(NodeEnum::CoerceToDomainValue(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::SetToDefault(n) => Ok(NodeEnum::SetToDefault(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::CurrentOfExpr(n) => Ok(NodeEnum::CurrentOfExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::NextValueExpr(n) => Ok(NodeEnum::NextValueExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::InferenceElem(n) => Ok(NodeEnum::InferenceElem(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::TargetEntry(n) => Ok(NodeEnum::TargetEntry(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::RangeTblRef(n) => Ok(NodeEnum::RangeTblRef(n.as_ref().ok_or(err)?.clone())),
NodeMut::JoinExpr(n) => Ok(NodeEnum::JoinExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::FromExpr(n) => Ok(NodeEnum::FromExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::OnConflictExpr(n) => Ok(NodeEnum::OnConflictExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::IntoClause(n) => Ok(NodeEnum::IntoClause(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::RawStmt(n) => Ok(NodeEnum::RawStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::Query(n) => Ok(NodeEnum::Query(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::InsertStmt(n) => Ok(NodeEnum::InsertStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::DeleteStmt(n) => Ok(NodeEnum::DeleteStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::UpdateStmt(n) => Ok(NodeEnum::UpdateStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::SelectStmt(n) => Ok(NodeEnum::SelectStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::AlterTableStmt(n) => Ok(NodeEnum::AlterTableStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::AlterTableCmd(n) => Ok(NodeEnum::AlterTableCmd(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::AlterDomainStmt(n) => Ok(NodeEnum::AlterDomainStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::SetOperationStmt(n) => Ok(NodeEnum::SetOperationStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::GrantStmt(n) => Ok(NodeEnum::GrantStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::GrantRoleStmt(n) => Ok(NodeEnum::GrantRoleStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::AlterDefaultPrivilegesStmt(n) => Ok(NodeEnum::AlterDefaultPrivilegesStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::ClosePortalStmt(n) => Ok(NodeEnum::ClosePortalStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::ClusterStmt(n) => Ok(NodeEnum::ClusterStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::CopyStmt(n) => Ok(NodeEnum::CopyStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::CreateStmt(n) => Ok(NodeEnum::CreateStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::DefineStmt(n) => Ok(NodeEnum::DefineStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::DropStmt(n) => Ok(NodeEnum::DropStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::TruncateStmt(n) => Ok(NodeEnum::TruncateStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::CommentStmt(n) => Ok(NodeEnum::CommentStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::FetchStmt(n) => Ok(NodeEnum::FetchStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::IndexStmt(n) => Ok(NodeEnum::IndexStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::CreateFunctionStmt(n) => Ok(NodeEnum::CreateFunctionStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::AlterFunctionStmt(n) => Ok(NodeEnum::AlterFunctionStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::DoStmt(n) => Ok(NodeEnum::DoStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::RenameStmt(n) => Ok(NodeEnum::RenameStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::RuleStmt(n) => Ok(NodeEnum::RuleStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::NotifyStmt(n) => Ok(NodeEnum::NotifyStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::ListenStmt(n) => Ok(NodeEnum::ListenStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::UnlistenStmt(n) => Ok(NodeEnum::UnlistenStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::TransactionStmt(n) => Ok(NodeEnum::TransactionStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::ViewStmt(n) => Ok(NodeEnum::ViewStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::LoadStmt(n) => Ok(NodeEnum::LoadStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::CreateDomainStmt(n) => Ok(NodeEnum::CreateDomainStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::CreatedbStmt(n) => Ok(NodeEnum::CreatedbStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::DropdbStmt(n) => Ok(NodeEnum::DropdbStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::VacuumStmt(n) => Ok(NodeEnum::VacuumStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::ExplainStmt(n) => Ok(NodeEnum::ExplainStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::CreateTableAsStmt(n) => Ok(NodeEnum::CreateTableAsStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::CreateSeqStmt(n) => Ok(NodeEnum::CreateSeqStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::AlterSeqStmt(n) => Ok(NodeEnum::AlterSeqStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::VariableSetStmt(n) => Ok(NodeEnum::VariableSetStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::VariableShowStmt(n) => Ok(NodeEnum::VariableShowStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::DiscardStmt(n) => Ok(NodeEnum::DiscardStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::CreateTrigStmt(n) => Ok(NodeEnum::CreateTrigStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::CreatePlangStmt(n) => Ok(NodeEnum::CreatePlangStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::CreateRoleStmt(n) => Ok(NodeEnum::CreateRoleStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::AlterRoleStmt(n) => Ok(NodeEnum::AlterRoleStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::DropRoleStmt(n) => Ok(NodeEnum::DropRoleStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::LockStmt(n) => Ok(NodeEnum::LockStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::ConstraintsSetStmt(n) => Ok(NodeEnum::ConstraintsSetStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::ReindexStmt(n) => Ok(NodeEnum::ReindexStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::CheckPointStmt(n) => Ok(NodeEnum::CheckPointStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::CreateSchemaStmt(n) => Ok(NodeEnum::CreateSchemaStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::AlterDatabaseStmt(n) => Ok(NodeEnum::AlterDatabaseStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::AlterDatabaseSetStmt(n) => Ok(NodeEnum::AlterDatabaseSetStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::AlterRoleSetStmt(n) => Ok(NodeEnum::AlterRoleSetStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::CreateConversionStmt(n) => Ok(NodeEnum::CreateConversionStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::CreateCastStmt(n) => Ok(NodeEnum::CreateCastStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::CreateOpClassStmt(n) => Ok(NodeEnum::CreateOpClassStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::CreateOpFamilyStmt(n) => Ok(NodeEnum::CreateOpFamilyStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::AlterOpFamilyStmt(n) => Ok(NodeEnum::AlterOpFamilyStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::PrepareStmt(n) => Ok(NodeEnum::PrepareStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::ExecuteStmt(n) => Ok(NodeEnum::ExecuteStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::DeallocateStmt(n) => Ok(NodeEnum::DeallocateStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::DeclareCursorStmt(n) => Ok(NodeEnum::DeclareCursorStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::CreateTableSpaceStmt(n) => Ok(NodeEnum::CreateTableSpaceStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::DropTableSpaceStmt(n) => Ok(NodeEnum::DropTableSpaceStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::AlterObjectDependsStmt(n) => Ok(NodeEnum::AlterObjectDependsStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::AlterObjectSchemaStmt(n) => Ok(NodeEnum::AlterObjectSchemaStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::AlterOwnerStmt(n) => Ok(NodeEnum::AlterOwnerStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::AlterOperatorStmt(n) => Ok(NodeEnum::AlterOperatorStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::AlterTypeStmt(n) => Ok(NodeEnum::AlterTypeStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::DropOwnedStmt(n) => Ok(NodeEnum::DropOwnedStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::ReassignOwnedStmt(n) => Ok(NodeEnum::ReassignOwnedStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::CompositeTypeStmt(n) => Ok(NodeEnum::CompositeTypeStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::CreateEnumStmt(n) => Ok(NodeEnum::CreateEnumStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::CreateRangeStmt(n) => Ok(NodeEnum::CreateRangeStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::AlterEnumStmt(n) => Ok(NodeEnum::AlterEnumStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::AlterTsdictionaryStmt(n) => Ok(NodeEnum::AlterTsdictionaryStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::AlterTsconfigurationStmt(n) => Ok(NodeEnum::AlterTsconfigurationStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::CreateFdwStmt(n) => Ok(NodeEnum::CreateFdwStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::AlterFdwStmt(n) => Ok(NodeEnum::AlterFdwStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::CreateForeignServerStmt(n) => Ok(NodeEnum::CreateForeignServerStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::AlterForeignServerStmt(n) => Ok(NodeEnum::AlterForeignServerStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::CreateUserMappingStmt(n) => Ok(NodeEnum::CreateUserMappingStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::AlterUserMappingStmt(n) => Ok(NodeEnum::AlterUserMappingStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::DropUserMappingStmt(n) => Ok(NodeEnum::DropUserMappingStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::AlterTableSpaceOptionsStmt(n) => Ok(NodeEnum::AlterTableSpaceOptionsStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::AlterTableMoveAllStmt(n) => Ok(NodeEnum::AlterTableMoveAllStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::SecLabelStmt(n) => Ok(NodeEnum::SecLabelStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::CreateForeignTableStmt(n) => Ok(NodeEnum::CreateForeignTableStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::ImportForeignSchemaStmt(n) => Ok(NodeEnum::ImportForeignSchemaStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::CreateExtensionStmt(n) => Ok(NodeEnum::CreateExtensionStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::AlterExtensionStmt(n) => Ok(NodeEnum::AlterExtensionStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::AlterExtensionContentsStmt(n) => Ok(NodeEnum::AlterExtensionContentsStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::CreateEventTrigStmt(n) => Ok(NodeEnum::CreateEventTrigStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::AlterEventTrigStmt(n) => Ok(NodeEnum::AlterEventTrigStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::RefreshMatViewStmt(n) => Ok(NodeEnum::RefreshMatViewStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::ReplicaIdentityStmt(n) => Ok(NodeEnum::ReplicaIdentityStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::AlterSystemStmt(n) => Ok(NodeEnum::AlterSystemStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::CreatePolicyStmt(n) => Ok(NodeEnum::CreatePolicyStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::AlterPolicyStmt(n) => Ok(NodeEnum::AlterPolicyStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::CreateTransformStmt(n) => Ok(NodeEnum::CreateTransformStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::CreateAmStmt(n) => Ok(NodeEnum::CreateAmStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::CreatePublicationStmt(n) => Ok(NodeEnum::CreatePublicationStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::AlterPublicationStmt(n) => Ok(NodeEnum::AlterPublicationStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::CreateSubscriptionStmt(n) => Ok(NodeEnum::CreateSubscriptionStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::AlterSubscriptionStmt(n) => Ok(NodeEnum::AlterSubscriptionStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::DropSubscriptionStmt(n) => Ok(NodeEnum::DropSubscriptionStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::CreateStatsStmt(n) => Ok(NodeEnum::CreateStatsStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::AlterCollationStmt(n) => Ok(NodeEnum::AlterCollationStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::CallStmt(n) => Ok(NodeEnum::CallStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::AlterStatsStmt(n) => Ok(NodeEnum::AlterStatsStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::AExpr(n) => Ok(NodeEnum::AExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::ColumnRef(n) => Ok(NodeEnum::ColumnRef(n.as_ref().ok_or(err)?.clone())),
NodeMut::ParamRef(n) => Ok(NodeEnum::ParamRef(n.as_ref().ok_or(err)?.clone())),
NodeMut::AConst(n) => Ok(NodeEnum::AConst(n.as_ref().ok_or(err)?.clone())),
NodeMut::FuncCall(n) => Ok(NodeEnum::FuncCall(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::AStar(n) => Ok(NodeEnum::AStar(n.as_ref().ok_or(err)?.clone())),
NodeMut::AIndices(n) => Ok(NodeEnum::AIndices(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::AIndirection(n) => Ok(NodeEnum::AIndirection(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::AArrayExpr(n) => Ok(NodeEnum::AArrayExpr(n.as_ref().ok_or(err)?.clone())),
NodeMut::ResTarget(n) => Ok(NodeEnum::ResTarget(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::MultiAssignRef(n) => Ok(NodeEnum::MultiAssignRef(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::TypeCast(n) => Ok(NodeEnum::TypeCast(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::CollateClause(n) => Ok(NodeEnum::CollateClause(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::SortBy(n) => Ok(NodeEnum::SortBy(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::WindowDef(n) => Ok(NodeEnum::WindowDef(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::RangeSubselect(n) => Ok(NodeEnum::RangeSubselect(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::RangeFunction(n) => Ok(NodeEnum::RangeFunction(n.as_ref().ok_or(err)?.clone())),
NodeMut::RangeTableSample(n) => Ok(NodeEnum::RangeTableSample(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::RangeTableFunc(n) => Ok(NodeEnum::RangeTableFunc(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::RangeTableFuncCol(n) => Ok(NodeEnum::RangeTableFuncCol(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::TypeName(n) => Ok(NodeEnum::TypeName(n.as_ref().ok_or(err)?.clone())),
NodeMut::ColumnDef(n) => Ok(NodeEnum::ColumnDef(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::IndexElem(n) => Ok(NodeEnum::IndexElem(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::Constraint(n) => Ok(NodeEnum::Constraint(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::DefElem(n) => Ok(NodeEnum::DefElem(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::RangeTblEntry(n) => Ok(NodeEnum::RangeTblEntry(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::RangeTblFunction(n) => Ok(NodeEnum::RangeTblFunction(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::TableSampleClause(n) => Ok(NodeEnum::TableSampleClause(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::WithCheckOption(n) => Ok(NodeEnum::WithCheckOption(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::SortGroupClause(n) => Ok(NodeEnum::SortGroupClause(n.as_ref().ok_or(err)?.clone())),
NodeMut::GroupingSet(n) => Ok(NodeEnum::GroupingSet(n.as_ref().ok_or(err)?.clone())),
NodeMut::WindowClause(n) => Ok(NodeEnum::WindowClause(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::ObjectWithArgs(n) => Ok(NodeEnum::ObjectWithArgs(n.as_ref().ok_or(err)?.clone())),
NodeMut::AccessPriv(n) => Ok(NodeEnum::AccessPriv(n.as_ref().ok_or(err)?.clone())),
NodeMut::CreateOpClassItem(n) => Ok(NodeEnum::CreateOpClassItem(n.as_ref().ok_or(err)?.clone())),
NodeMut::TableLikeClause(n) => Ok(NodeEnum::TableLikeClause(n.as_ref().ok_or(err)?.clone())),
NodeMut::FunctionParameter(n) => Ok(NodeEnum::FunctionParameter(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::LockingClause(n) => Ok(NodeEnum::LockingClause(n.as_ref().ok_or(err)?.clone())),
NodeMut::RowMarkClause(n) => Ok(NodeEnum::RowMarkClause(n.as_ref().ok_or(err)?.clone())),
NodeMut::XmlSerialize(n) => Ok(NodeEnum::XmlSerialize(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::WithClause(n) => Ok(NodeEnum::WithClause(n.as_ref().ok_or(err)?.clone())),
NodeMut::InferClause(n) => Ok(NodeEnum::InferClause(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::OnConflictClause(n) => Ok(NodeEnum::OnConflictClause(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::CommonTableExpr(n) => Ok(NodeEnum::CommonTableExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::RoleSpec(n) => Ok(NodeEnum::RoleSpec(n.as_ref().ok_or(err)?.clone())),
NodeMut::TriggerTransition(n) => Ok(NodeEnum::TriggerTransition(n.as_ref().ok_or(err)?.clone())),
NodeMut::PartitionElem(n) => Ok(NodeEnum::PartitionElem(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::PartitionSpec(n) => Ok(NodeEnum::PartitionSpec(n.as_ref().ok_or(err)?.clone())),
NodeMut::PartitionBoundSpec(n) => Ok(NodeEnum::PartitionBoundSpec(n.as_ref().ok_or(err)?.clone())),
NodeMut::PartitionRangeDatum(n) => Ok(NodeEnum::PartitionRangeDatum(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::PartitionCmd(n) => Ok(NodeEnum::PartitionCmd(n.as_ref().ok_or(err)?.clone())),
NodeMut::VacuumRelation(n) => Ok(NodeEnum::VacuumRelation(n.as_ref().ok_or(err)?.clone())),
NodeMut::InlineCodeBlock(n) => Ok(NodeEnum::InlineCodeBlock(n.as_ref().ok_or(err)?.clone())),
NodeMut::CallContext(n) => Ok(NodeEnum::CallContext(n.as_ref().ok_or(err)?.clone())),
NodeMut::Integer(n) => Ok(NodeEnum::Integer(n.as_ref().ok_or(err)?.clone())),
NodeMut::Float(n) => Ok(NodeEnum::Float(n.as_ref().ok_or(err)?.clone())),
NodeMut::Boolean(n) => Ok(NodeEnum::Boolean(n.as_ref().ok_or(err)?.clone())),
NodeMut::String(n) => Ok(NodeEnum::String(n.as_ref().ok_or(err)?.clone())),
NodeMut::BitString(n) => Ok(NodeEnum::BitString(n.as_ref().ok_or(err)?.clone())),
NodeMut::List(n) => Ok(NodeEnum::List(n.as_ref().ok_or(err)?.clone())),
NodeMut::IntList(n) => Ok(NodeEnum::IntList(n.as_ref().ok_or(err)?.clone())),
NodeMut::OidList(n) => Ok(NodeEnum::OidList(n.as_ref().ok_or(err)?.clone())),
NodeMut::MergeStmt(n) => Ok(NodeEnum::MergeStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::MergeAction(n) => Ok(NodeEnum::MergeAction(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::AlterDatabaseRefreshCollStmt(n) => Ok(NodeEnum::AlterDatabaseRefreshCollStmt(n.as_ref().ok_or(err)?.clone())),
NodeMut::ReturnStmt(n) => Ok(NodeEnum::ReturnStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::PlassignStmt(n) => Ok(NodeEnum::PlassignStmt(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::StatsElem(n) => Ok(NodeEnum::StatsElem(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::CtesearchClause(n) => Ok(NodeEnum::CtesearchClause(n.as_ref().ok_or(err)?.clone())),
NodeMut::CtecycleClause(n) => Ok(NodeEnum::CtecycleClause(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::MergeWhenClause(n) => Ok(NodeEnum::MergeWhenClause(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::PublicationObjSpec(n) => Ok(NodeEnum::PublicationObjSpec(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::PublicationTable(n) => Ok(NodeEnum::PublicationTable(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::JsonFormat(n) => Ok(NodeEnum::JsonFormat(n.as_ref().ok_or(err)?.clone())),
NodeMut::JsonReturning(n) => Ok(NodeEnum::JsonReturning(n.as_ref().ok_or(err)?.clone())),
NodeMut::JsonValueExpr(n) => Ok(NodeEnum::JsonValueExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::JsonConstructorExpr(n) => Ok(NodeEnum::JsonConstructorExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::JsonIsPredicate(n) => Ok(NodeEnum::JsonIsPredicate(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::JsonOutput(n) => Ok(NodeEnum::JsonOutput(n.as_ref().ok_or(err)?.clone())),
NodeMut::JsonKeyValue(n) => Ok(NodeEnum::JsonKeyValue(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::JsonObjectConstructor(n) => Ok(NodeEnum::JsonObjectConstructor(n.as_ref().ok_or(err)?.clone())),
NodeMut::JsonArrayConstructor(n) => Ok(NodeEnum::JsonArrayConstructor(n.as_ref().ok_or(err)?.clone())),
NodeMut::JsonArrayQueryConstructor(n) => Ok(NodeEnum::JsonArrayQueryConstructor(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::JsonAggConstructor(n) => Ok(NodeEnum::JsonAggConstructor(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::JsonObjectAgg(n) => Ok(NodeEnum::JsonObjectAgg(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::JsonArrayAgg(n) => Ok(NodeEnum::JsonArrayAgg(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::RtepermissionInfo(n) => Ok(NodeEnum::RtepermissionInfo(n.as_ref().ok_or(err)?.clone())),
NodeMut::WindowFuncRunCondition(n) => Ok(NodeEnum::WindowFuncRunCondition(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::MergeSupportFunc(n) => Ok(NodeEnum::MergeSupportFunc(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::JsonBehavior(n) => Ok(NodeEnum::JsonBehavior(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::JsonExpr(n) => Ok(NodeEnum::JsonExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::JsonTablePath(n) => Ok(NodeEnum::JsonTablePath(n.as_ref().ok_or(err)?.clone())),
NodeMut::JsonTablePathScan(n) => Ok(NodeEnum::JsonTablePathScan(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::JsonTableSiblingJoin(n) => Ok(NodeEnum::JsonTableSiblingJoin(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::SinglePartitionSpec(n) => Ok(NodeEnum::SinglePartitionSpec(n.as_ref().ok_or(err)?.clone())),
NodeMut::JsonArgument(n) => Ok(NodeEnum::JsonArgument(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::JsonFuncExpr(n) => Ok(NodeEnum::JsonFuncExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::JsonTablePathSpec(n) => Ok(NodeEnum::JsonTablePathSpec(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::JsonTable(n) => Ok(NodeEnum::JsonTable(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::JsonTableColumn(n) => Ok(NodeEnum::JsonTableColumn(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::JsonParseExpr(n) => Ok(NodeEnum::JsonParseExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::JsonScalarExpr(n) => Ok(NodeEnum::JsonScalarExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
NodeMut::JsonSerializeExpr(n) => Ok(NodeEnum::JsonSerializeExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
}
}
}
}