1use crate::*;
2
3#[derive(Debug, Copy, Clone)]
4pub enum NodeMut {
5 Alias(*mut protobuf::Alias),
6 RangeVar(*mut protobuf::RangeVar),
7 TableFunc(*mut protobuf::TableFunc),
8 Var(*mut protobuf::Var),
9 Param(*mut protobuf::Param),
10 Aggref(*mut protobuf::Aggref),
11 GroupingFunc(*mut protobuf::GroupingFunc),
12 WindowFunc(*mut protobuf::WindowFunc),
13 SubscriptingRef(*mut protobuf::SubscriptingRef),
14 FuncExpr(*mut protobuf::FuncExpr),
15 NamedArgExpr(*mut protobuf::NamedArgExpr),
16 OpExpr(*mut protobuf::OpExpr),
17 DistinctExpr(*mut protobuf::DistinctExpr),
18 NullIfExpr(*mut protobuf::NullIfExpr),
19 ScalarArrayOpExpr(*mut protobuf::ScalarArrayOpExpr),
20 BoolExpr(*mut protobuf::BoolExpr),
21 SubLink(*mut protobuf::SubLink),
22 SubPlan(*mut protobuf::SubPlan),
23 AlternativeSubPlan(*mut protobuf::AlternativeSubPlan),
24 FieldSelect(*mut protobuf::FieldSelect),
25 FieldStore(*mut protobuf::FieldStore),
26 RelabelType(*mut protobuf::RelabelType),
27 CoerceViaIo(*mut protobuf::CoerceViaIo),
28 ArrayCoerceExpr(*mut protobuf::ArrayCoerceExpr),
29 ConvertRowtypeExpr(*mut protobuf::ConvertRowtypeExpr),
30 CollateExpr(*mut protobuf::CollateExpr),
31 CaseExpr(*mut protobuf::CaseExpr),
32 CaseWhen(*mut protobuf::CaseWhen),
33 CaseTestExpr(*mut protobuf::CaseTestExpr),
34 ArrayExpr(*mut protobuf::ArrayExpr),
35 RowExpr(*mut protobuf::RowExpr),
36 RowCompareExpr(*mut protobuf::RowCompareExpr),
37 CoalesceExpr(*mut protobuf::CoalesceExpr),
38 MinMaxExpr(*mut protobuf::MinMaxExpr),
39 SqlvalueFunction(*mut protobuf::SqlValueFunction),
40 XmlExpr(*mut protobuf::XmlExpr),
41 NullTest(*mut protobuf::NullTest),
42 BooleanTest(*mut protobuf::BooleanTest),
43 CoerceToDomain(*mut protobuf::CoerceToDomain),
44 CoerceToDomainValue(*mut protobuf::CoerceToDomainValue),
45 SetToDefault(*mut protobuf::SetToDefault),
46 CurrentOfExpr(*mut protobuf::CurrentOfExpr),
47 NextValueExpr(*mut protobuf::NextValueExpr),
48 InferenceElem(*mut protobuf::InferenceElem),
49 TargetEntry(*mut protobuf::TargetEntry),
50 RangeTblRef(*mut protobuf::RangeTblRef),
51 JoinExpr(*mut protobuf::JoinExpr),
52 FromExpr(*mut protobuf::FromExpr),
53 OnConflictExpr(*mut protobuf::OnConflictExpr),
54 IntoClause(*mut protobuf::IntoClause),
55 RawStmt(*mut protobuf::RawStmt),
56 Query(*mut protobuf::Query),
57 InsertStmt(*mut protobuf::InsertStmt),
58 DeleteStmt(*mut protobuf::DeleteStmt),
59 UpdateStmt(*mut protobuf::UpdateStmt),
60 SelectStmt(*mut protobuf::SelectStmt),
61 AlterTableStmt(*mut protobuf::AlterTableStmt),
62 AlterTableCmd(*mut protobuf::AlterTableCmd),
63 AlterDomainStmt(*mut protobuf::AlterDomainStmt),
64 SetOperationStmt(*mut protobuf::SetOperationStmt),
65 GrantStmt(*mut protobuf::GrantStmt),
66 GrantRoleStmt(*mut protobuf::GrantRoleStmt),
67 AlterDefaultPrivilegesStmt(*mut protobuf::AlterDefaultPrivilegesStmt),
68 ClosePortalStmt(*mut protobuf::ClosePortalStmt),
69 ClusterStmt(*mut protobuf::ClusterStmt),
70 CopyStmt(*mut protobuf::CopyStmt),
71 CreateStmt(*mut protobuf::CreateStmt),
72 DefineStmt(*mut protobuf::DefineStmt),
73 DropStmt(*mut protobuf::DropStmt),
74 TruncateStmt(*mut protobuf::TruncateStmt),
75 CommentStmt(*mut protobuf::CommentStmt),
76 FetchStmt(*mut protobuf::FetchStmt),
77 IndexStmt(*mut protobuf::IndexStmt),
78 CreateFunctionStmt(*mut protobuf::CreateFunctionStmt),
79 AlterFunctionStmt(*mut protobuf::AlterFunctionStmt),
80 DoStmt(*mut protobuf::DoStmt),
81 RenameStmt(*mut protobuf::RenameStmt),
82 RuleStmt(*mut protobuf::RuleStmt),
83 NotifyStmt(*mut protobuf::NotifyStmt),
84 ListenStmt(*mut protobuf::ListenStmt),
85 UnlistenStmt(*mut protobuf::UnlistenStmt),
86 TransactionStmt(*mut protobuf::TransactionStmt),
87 ViewStmt(*mut protobuf::ViewStmt),
88 LoadStmt(*mut protobuf::LoadStmt),
89 CreateDomainStmt(*mut protobuf::CreateDomainStmt),
90 CreatedbStmt(*mut protobuf::CreatedbStmt),
91 DropdbStmt(*mut protobuf::DropdbStmt),
92 VacuumStmt(*mut protobuf::VacuumStmt),
93 ExplainStmt(*mut protobuf::ExplainStmt),
94 CreateTableAsStmt(*mut protobuf::CreateTableAsStmt),
95 CreateSeqStmt(*mut protobuf::CreateSeqStmt),
96 AlterSeqStmt(*mut protobuf::AlterSeqStmt),
97 VariableSetStmt(*mut protobuf::VariableSetStmt),
98 VariableShowStmt(*mut protobuf::VariableShowStmt),
99 DiscardStmt(*mut protobuf::DiscardStmt),
100 CreateTrigStmt(*mut protobuf::CreateTrigStmt),
101 CreatePlangStmt(*mut protobuf::CreatePLangStmt),
102 CreateRoleStmt(*mut protobuf::CreateRoleStmt),
103 AlterRoleStmt(*mut protobuf::AlterRoleStmt),
104 DropRoleStmt(*mut protobuf::DropRoleStmt),
105 LockStmt(*mut protobuf::LockStmt),
106 ConstraintsSetStmt(*mut protobuf::ConstraintsSetStmt),
107 ReindexStmt(*mut protobuf::ReindexStmt),
108 CheckPointStmt(*mut protobuf::CheckPointStmt),
109 CreateSchemaStmt(*mut protobuf::CreateSchemaStmt),
110 AlterDatabaseStmt(*mut protobuf::AlterDatabaseStmt),
111 AlterDatabaseSetStmt(*mut protobuf::AlterDatabaseSetStmt),
112 AlterRoleSetStmt(*mut protobuf::AlterRoleSetStmt),
113 CreateConversionStmt(*mut protobuf::CreateConversionStmt),
114 CreateCastStmt(*mut protobuf::CreateCastStmt),
115 CreateOpClassStmt(*mut protobuf::CreateOpClassStmt),
116 CreateOpFamilyStmt(*mut protobuf::CreateOpFamilyStmt),
117 AlterOpFamilyStmt(*mut protobuf::AlterOpFamilyStmt),
118 PrepareStmt(*mut protobuf::PrepareStmt),
119 ExecuteStmt(*mut protobuf::ExecuteStmt),
120 DeallocateStmt(*mut protobuf::DeallocateStmt),
121 DeclareCursorStmt(*mut protobuf::DeclareCursorStmt),
122 CreateTableSpaceStmt(*mut protobuf::CreateTableSpaceStmt),
123 DropTableSpaceStmt(*mut protobuf::DropTableSpaceStmt),
124 AlterObjectDependsStmt(*mut protobuf::AlterObjectDependsStmt),
125 AlterObjectSchemaStmt(*mut protobuf::AlterObjectSchemaStmt),
126 AlterOwnerStmt(*mut protobuf::AlterOwnerStmt),
127 AlterOperatorStmt(*mut protobuf::AlterOperatorStmt),
128 AlterTypeStmt(*mut protobuf::AlterTypeStmt),
129 AtalterConstraint(*mut protobuf::AtAlterConstraint),
130 DropOwnedStmt(*mut protobuf::DropOwnedStmt),
131 ReassignOwnedStmt(*mut protobuf::ReassignOwnedStmt),
132 CompositeTypeStmt(*mut protobuf::CompositeTypeStmt),
133 CreateEnumStmt(*mut protobuf::CreateEnumStmt),
134 CreateRangeStmt(*mut protobuf::CreateRangeStmt),
135 AlterEnumStmt(*mut protobuf::AlterEnumStmt),
136 AlterTsdictionaryStmt(*mut protobuf::AlterTsDictionaryStmt),
137 AlterTsconfigurationStmt(*mut protobuf::AlterTsConfigurationStmt),
138 CreateFdwStmt(*mut protobuf::CreateFdwStmt),
139 AlterFdwStmt(*mut protobuf::AlterFdwStmt),
140 CreateForeignServerStmt(*mut protobuf::CreateForeignServerStmt),
141 AlterForeignServerStmt(*mut protobuf::AlterForeignServerStmt),
142 CreateUserMappingStmt(*mut protobuf::CreateUserMappingStmt),
143 AlterUserMappingStmt(*mut protobuf::AlterUserMappingStmt),
144 DropUserMappingStmt(*mut protobuf::DropUserMappingStmt),
145 AlterTableSpaceOptionsStmt(*mut protobuf::AlterTableSpaceOptionsStmt),
146 AlterTableMoveAllStmt(*mut protobuf::AlterTableMoveAllStmt),
147 SecLabelStmt(*mut protobuf::SecLabelStmt),
148 CreateForeignTableStmt(*mut protobuf::CreateForeignTableStmt),
149 ImportForeignSchemaStmt(*mut protobuf::ImportForeignSchemaStmt),
150 CreateExtensionStmt(*mut protobuf::CreateExtensionStmt),
151 AlterExtensionStmt(*mut protobuf::AlterExtensionStmt),
152 AlterExtensionContentsStmt(*mut protobuf::AlterExtensionContentsStmt),
153 CreateEventTrigStmt(*mut protobuf::CreateEventTrigStmt),
154 AlterEventTrigStmt(*mut protobuf::AlterEventTrigStmt),
155 RefreshMatViewStmt(*mut protobuf::RefreshMatViewStmt),
156 ReplicaIdentityStmt(*mut protobuf::ReplicaIdentityStmt),
157 AlterSystemStmt(*mut protobuf::AlterSystemStmt),
158 CreatePolicyStmt(*mut protobuf::CreatePolicyStmt),
159 AlterPolicyStmt(*mut protobuf::AlterPolicyStmt),
160 CreateTransformStmt(*mut protobuf::CreateTransformStmt),
161 CreateAmStmt(*mut protobuf::CreateAmStmt),
162 CreatePublicationStmt(*mut protobuf::CreatePublicationStmt),
163 AlterPublicationStmt(*mut protobuf::AlterPublicationStmt),
164 CreateSubscriptionStmt(*mut protobuf::CreateSubscriptionStmt),
165 AlterSubscriptionStmt(*mut protobuf::AlterSubscriptionStmt),
166 DropSubscriptionStmt(*mut protobuf::DropSubscriptionStmt),
167 CreateStatsStmt(*mut protobuf::CreateStatsStmt),
168 AlterCollationStmt(*mut protobuf::AlterCollationStmt),
169 CallStmt(*mut protobuf::CallStmt),
170 AlterStatsStmt(*mut protobuf::AlterStatsStmt),
171 AExpr(*mut protobuf::AExpr),
172 ColumnRef(*mut protobuf::ColumnRef),
173 ParamRef(*mut protobuf::ParamRef),
174 AConst(*mut protobuf::AConst),
175 FuncCall(*mut protobuf::FuncCall),
176 AStar(*mut protobuf::AStar),
177 AIndices(*mut protobuf::AIndices),
178 AIndirection(*mut protobuf::AIndirection),
179 AArrayExpr(*mut protobuf::AArrayExpr),
180 ResTarget(*mut protobuf::ResTarget),
181 MultiAssignRef(*mut protobuf::MultiAssignRef),
182 TypeCast(*mut protobuf::TypeCast),
183 CollateClause(*mut protobuf::CollateClause),
184 SortBy(*mut protobuf::SortBy),
185 WindowDef(*mut protobuf::WindowDef),
186 RangeSubselect(*mut protobuf::RangeSubselect),
187 RangeFunction(*mut protobuf::RangeFunction),
188 RangeTableSample(*mut protobuf::RangeTableSample),
189 RangeTableFunc(*mut protobuf::RangeTableFunc),
190 RangeTableFuncCol(*mut protobuf::RangeTableFuncCol),
191 TypeName(*mut protobuf::TypeName),
192 ColumnDef(*mut protobuf::ColumnDef),
193 IndexElem(*mut protobuf::IndexElem),
194 Constraint(*mut protobuf::Constraint),
195 DefElem(*mut protobuf::DefElem),
196 RangeTblEntry(*mut protobuf::RangeTblEntry),
197 RangeTblFunction(*mut protobuf::RangeTblFunction),
198 TableSampleClause(*mut protobuf::TableSampleClause),
199 WithCheckOption(*mut protobuf::WithCheckOption),
200 SortGroupClause(*mut protobuf::SortGroupClause),
201 GroupingSet(*mut protobuf::GroupingSet),
202 WindowClause(*mut protobuf::WindowClause),
203 ObjectWithArgs(*mut protobuf::ObjectWithArgs),
204 AccessPriv(*mut protobuf::AccessPriv),
205 CreateOpClassItem(*mut protobuf::CreateOpClassItem),
206 TableLikeClause(*mut protobuf::TableLikeClause),
207 FunctionParameter(*mut protobuf::FunctionParameter),
208 LockingClause(*mut protobuf::LockingClause),
209 RowMarkClause(*mut protobuf::RowMarkClause),
210 XmlSerialize(*mut protobuf::XmlSerialize),
211 WithClause(*mut protobuf::WithClause),
212 InferClause(*mut protobuf::InferClause),
213 OnConflictClause(*mut protobuf::OnConflictClause),
214 CommonTableExpr(*mut protobuf::CommonTableExpr),
215 RoleSpec(*mut protobuf::RoleSpec),
216 TriggerTransition(*mut protobuf::TriggerTransition),
217 PartitionElem(*mut protobuf::PartitionElem),
218 PartitionSpec(*mut protobuf::PartitionSpec),
219 PartitionBoundSpec(*mut protobuf::PartitionBoundSpec),
220 PartitionRangeDatum(*mut protobuf::PartitionRangeDatum),
221 PartitionCmd(*mut protobuf::PartitionCmd),
222 VacuumRelation(*mut protobuf::VacuumRelation),
223 InlineCodeBlock(*mut protobuf::InlineCodeBlock),
224 CallContext(*mut protobuf::CallContext),
225 Integer(*mut protobuf::Integer),
226 Float(*mut protobuf::Float),
227 Boolean(*mut protobuf::Boolean),
228 String(*mut protobuf::String),
229 BitString(*mut protobuf::BitString),
230 List(*mut protobuf::List),
231 IntList(*mut protobuf::IntList),
232 OidList(*mut protobuf::OidList),
233 MergeStmt(*mut protobuf::MergeStmt),
234 MergeAction(*mut protobuf::MergeAction),
235 AlterDatabaseRefreshCollStmt(*mut protobuf::AlterDatabaseRefreshCollStmt),
236 ReturnStmt(*mut protobuf::ReturnStmt),
237 ReturningClause(*mut protobuf::ReturningClause),
238 ReturningExpr(*mut protobuf::ReturningExpr),
239 ReturningOption(*mut protobuf::ReturningOption),
240 PlassignStmt(*mut protobuf::PlAssignStmt),
241 StatsElem(*mut protobuf::StatsElem),
242 CtesearchClause(*mut protobuf::CteSearchClause),
243 CtecycleClause(*mut protobuf::CteCycleClause),
244 MergeWhenClause(*mut protobuf::MergeWhenClause),
245 PublicationObjSpec(*mut protobuf::PublicationObjSpec),
246 PublicationTable(*mut protobuf::PublicationTable),
247 JsonFormat(*mut protobuf::JsonFormat),
248 JsonReturning(*mut protobuf::JsonReturning),
249 JsonValueExpr(*mut protobuf::JsonValueExpr),
250 JsonConstructorExpr(*mut protobuf::JsonConstructorExpr),
251 JsonIsPredicate(*mut protobuf::JsonIsPredicate),
252 JsonOutput(*mut protobuf::JsonOutput),
253 JsonKeyValue(*mut protobuf::JsonKeyValue),
254 JsonObjectConstructor(*mut protobuf::JsonObjectConstructor),
255 JsonArrayConstructor(*mut protobuf::JsonArrayConstructor),
256 JsonArrayQueryConstructor(*mut protobuf::JsonArrayQueryConstructor),
257 JsonAggConstructor(*mut protobuf::JsonAggConstructor),
258 JsonObjectAgg(*mut protobuf::JsonObjectAgg),
259 JsonArrayAgg(*mut protobuf::JsonArrayAgg),
260 RtepermissionInfo(*mut protobuf::RtePermissionInfo),
261 WindowFuncRunCondition(*mut protobuf::WindowFuncRunCondition),
262 MergeSupportFunc(*mut protobuf::MergeSupportFunc),
263 JsonBehavior(*mut protobuf::JsonBehavior),
264 JsonExpr(*mut protobuf::JsonExpr),
265 JsonTablePath(*mut protobuf::JsonTablePath),
266 JsonTablePathScan(*mut protobuf::JsonTablePathScan),
267 JsonTableSiblingJoin(*mut protobuf::JsonTableSiblingJoin),
268 JsonArgument(*mut protobuf::JsonArgument),
269 JsonFuncExpr(*mut protobuf::JsonFuncExpr),
270 JsonTablePathSpec(*mut protobuf::JsonTablePathSpec),
271 JsonTable(*mut protobuf::JsonTable),
272 JsonTableColumn(*mut protobuf::JsonTableColumn),
273 JsonParseExpr(*mut protobuf::JsonParseExpr),
274 JsonScalarExpr(*mut protobuf::JsonScalarExpr),
275 JsonSerializeExpr(*mut protobuf::JsonSerializeExpr),
276}
277
278impl NodeMut {
279 pub fn deparse(&self) -> Result<String> {
280 crate::deparse(&protobuf::ParseResult {
281 version: crate::bindings::PG_VERSION_NUM as i32,
282 stmts: vec![protobuf::RawStmt {
283 stmt: Some(Box::new(Node {
284 node: Some(self.to_enum()?),
285 })),
286 stmt_location: 0,
287 stmt_len: 0,
288 }],
289 })
290 }
291
292 pub fn to_enum(&self) -> Result<NodeEnum> {
293 unsafe {
294 let err = Error::InvalidPointer;
295 match self {
296 NodeMut::Alias(n) => Ok(NodeEnum::Alias(n.as_ref().ok_or(err)?.clone())),
297 NodeMut::RangeVar(n) => Ok(NodeEnum::RangeVar(n.as_ref().ok_or(err)?.clone())),
298 NodeMut::TableFunc(n) => Ok(NodeEnum::TableFunc(Box::new(
299 n.as_ref().ok_or(err)?.clone(),
300 ))),
301 NodeMut::Var(n) => Ok(NodeEnum::Var(Box::new(n.as_ref().ok_or(err)?.clone()))),
302 NodeMut::Param(n) => Ok(NodeEnum::Param(Box::new(n.as_ref().ok_or(err)?.clone()))),
303 NodeMut::Aggref(n) => {
304 Ok(NodeEnum::Aggref(Box::new(n.as_ref().ok_or(err)?.clone())))
305 }
306 NodeMut::GroupingFunc(n) => Ok(NodeEnum::GroupingFunc(Box::new(
307 n.as_ref().ok_or(err)?.clone(),
308 ))),
309 NodeMut::WindowFunc(n) => Ok(NodeEnum::WindowFunc(Box::new(
310 n.as_ref().ok_or(err)?.clone(),
311 ))),
312 NodeMut::SubscriptingRef(n) => Ok(NodeEnum::SubscriptingRef(Box::new(
313 n.as_ref().ok_or(err)?.clone(),
314 ))),
315 NodeMut::FuncExpr(n) => {
316 Ok(NodeEnum::FuncExpr(Box::new(n.as_ref().ok_or(err)?.clone())))
317 }
318 NodeMut::NamedArgExpr(n) => Ok(NodeEnum::NamedArgExpr(Box::new(
319 n.as_ref().ok_or(err)?.clone(),
320 ))),
321 NodeMut::OpExpr(n) => {
322 Ok(NodeEnum::OpExpr(Box::new(n.as_ref().ok_or(err)?.clone())))
323 }
324 NodeMut::DistinctExpr(n) => Ok(NodeEnum::DistinctExpr(Box::new(
325 n.as_ref().ok_or(err)?.clone(),
326 ))),
327 NodeMut::NullIfExpr(n) => Ok(NodeEnum::NullIfExpr(Box::new(
328 n.as_ref().ok_or(err)?.clone(),
329 ))),
330 NodeMut::ScalarArrayOpExpr(n) => Ok(NodeEnum::ScalarArrayOpExpr(Box::new(
331 n.as_ref().ok_or(err)?.clone(),
332 ))),
333 NodeMut::BoolExpr(n) => {
334 Ok(NodeEnum::BoolExpr(Box::new(n.as_ref().ok_or(err)?.clone())))
335 }
336 NodeMut::SubLink(n) => {
337 Ok(NodeEnum::SubLink(Box::new(n.as_ref().ok_or(err)?.clone())))
338 }
339 NodeMut::SubPlan(n) => {
340 Ok(NodeEnum::SubPlan(Box::new(n.as_ref().ok_or(err)?.clone())))
341 }
342 NodeMut::AlternativeSubPlan(n) => Ok(NodeEnum::AlternativeSubPlan(Box::new(
343 n.as_ref().ok_or(err)?.clone(),
344 ))),
345 NodeMut::FieldSelect(n) => Ok(NodeEnum::FieldSelect(Box::new(
346 n.as_ref().ok_or(err)?.clone(),
347 ))),
348 NodeMut::FieldStore(n) => Ok(NodeEnum::FieldStore(Box::new(
349 n.as_ref().ok_or(err)?.clone(),
350 ))),
351 NodeMut::RelabelType(n) => Ok(NodeEnum::RelabelType(Box::new(
352 n.as_ref().ok_or(err)?.clone(),
353 ))),
354 NodeMut::CoerceViaIo(n) => Ok(NodeEnum::CoerceViaIo(Box::new(
355 n.as_ref().ok_or(err)?.clone(),
356 ))),
357 NodeMut::ArrayCoerceExpr(n) => Ok(NodeEnum::ArrayCoerceExpr(Box::new(
358 n.as_ref().ok_or(err)?.clone(),
359 ))),
360 NodeMut::ConvertRowtypeExpr(n) => Ok(NodeEnum::ConvertRowtypeExpr(Box::new(
361 n.as_ref().ok_or(err)?.clone(),
362 ))),
363 NodeMut::CollateExpr(n) => Ok(NodeEnum::CollateExpr(Box::new(
364 n.as_ref().ok_or(err)?.clone(),
365 ))),
366 NodeMut::CaseExpr(n) => {
367 Ok(NodeEnum::CaseExpr(Box::new(n.as_ref().ok_or(err)?.clone())))
368 }
369 NodeMut::CaseWhen(n) => {
370 Ok(NodeEnum::CaseWhen(Box::new(n.as_ref().ok_or(err)?.clone())))
371 }
372 NodeMut::CaseTestExpr(n) => Ok(NodeEnum::CaseTestExpr(Box::new(
373 n.as_ref().ok_or(err)?.clone(),
374 ))),
375 NodeMut::ArrayExpr(n) => Ok(NodeEnum::ArrayExpr(Box::new(
376 n.as_ref().ok_or(err)?.clone(),
377 ))),
378 NodeMut::RowExpr(n) => {
379 Ok(NodeEnum::RowExpr(Box::new(n.as_ref().ok_or(err)?.clone())))
380 }
381 NodeMut::RowCompareExpr(n) => Ok(NodeEnum::RowCompareExpr(Box::new(
382 n.as_ref().ok_or(err)?.clone(),
383 ))),
384 NodeMut::CoalesceExpr(n) => Ok(NodeEnum::CoalesceExpr(Box::new(
385 n.as_ref().ok_or(err)?.clone(),
386 ))),
387 NodeMut::MinMaxExpr(n) => Ok(NodeEnum::MinMaxExpr(Box::new(
388 n.as_ref().ok_or(err)?.clone(),
389 ))),
390 NodeMut::SqlvalueFunction(n) => Ok(NodeEnum::SqlvalueFunction(Box::new(
391 n.as_ref().ok_or(err)?.clone(),
392 ))),
393 NodeMut::XmlExpr(n) => {
394 Ok(NodeEnum::XmlExpr(Box::new(n.as_ref().ok_or(err)?.clone())))
395 }
396 NodeMut::NullTest(n) => {
397 Ok(NodeEnum::NullTest(Box::new(n.as_ref().ok_or(err)?.clone())))
398 }
399 NodeMut::BooleanTest(n) => Ok(NodeEnum::BooleanTest(Box::new(
400 n.as_ref().ok_or(err)?.clone(),
401 ))),
402 NodeMut::CoerceToDomain(n) => Ok(NodeEnum::CoerceToDomain(Box::new(
403 n.as_ref().ok_or(err)?.clone(),
404 ))),
405 NodeMut::CoerceToDomainValue(n) => Ok(NodeEnum::CoerceToDomainValue(Box::new(
406 n.as_ref().ok_or(err)?.clone(),
407 ))),
408 NodeMut::SetToDefault(n) => Ok(NodeEnum::SetToDefault(Box::new(
409 n.as_ref().ok_or(err)?.clone(),
410 ))),
411 NodeMut::CurrentOfExpr(n) => Ok(NodeEnum::CurrentOfExpr(Box::new(
412 n.as_ref().ok_or(err)?.clone(),
413 ))),
414 NodeMut::NextValueExpr(n) => Ok(NodeEnum::NextValueExpr(Box::new(
415 n.as_ref().ok_or(err)?.clone(),
416 ))),
417 NodeMut::InferenceElem(n) => Ok(NodeEnum::InferenceElem(Box::new(
418 n.as_ref().ok_or(err)?.clone(),
419 ))),
420 NodeMut::TargetEntry(n) => Ok(NodeEnum::TargetEntry(Box::new(
421 n.as_ref().ok_or(err)?.clone(),
422 ))),
423 NodeMut::RangeTblRef(n) => {
424 Ok(NodeEnum::RangeTblRef(n.as_ref().ok_or(err)?.clone()))
425 }
426 NodeMut::JoinExpr(n) => {
427 Ok(NodeEnum::JoinExpr(Box::new(n.as_ref().ok_or(err)?.clone())))
428 }
429 NodeMut::FromExpr(n) => {
430 Ok(NodeEnum::FromExpr(Box::new(n.as_ref().ok_or(err)?.clone())))
431 }
432 NodeMut::OnConflictExpr(n) => Ok(NodeEnum::OnConflictExpr(Box::new(
433 n.as_ref().ok_or(err)?.clone(),
434 ))),
435 NodeMut::IntoClause(n) => Ok(NodeEnum::IntoClause(Box::new(
436 n.as_ref().ok_or(err)?.clone(),
437 ))),
438 NodeMut::RawStmt(n) => {
439 Ok(NodeEnum::RawStmt(Box::new(n.as_ref().ok_or(err)?.clone())))
440 }
441 NodeMut::Query(n) => Ok(NodeEnum::Query(Box::new(n.as_ref().ok_or(err)?.clone()))),
442 NodeMut::InsertStmt(n) => Ok(NodeEnum::InsertStmt(Box::new(
443 n.as_ref().ok_or(err)?.clone(),
444 ))),
445 NodeMut::DeleteStmt(n) => Ok(NodeEnum::DeleteStmt(Box::new(
446 n.as_ref().ok_or(err)?.clone(),
447 ))),
448 NodeMut::UpdateStmt(n) => Ok(NodeEnum::UpdateStmt(Box::new(
449 n.as_ref().ok_or(err)?.clone(),
450 ))),
451 NodeMut::SelectStmt(n) => Ok(NodeEnum::SelectStmt(Box::new(
452 n.as_ref().ok_or(err)?.clone(),
453 ))),
454 NodeMut::AlterTableStmt(n) => {
455 Ok(NodeEnum::AlterTableStmt(n.as_ref().ok_or(err)?.clone()))
456 }
457 NodeMut::AlterTableCmd(n) => Ok(NodeEnum::AlterTableCmd(Box::new(
458 n.as_ref().ok_or(err)?.clone(),
459 ))),
460 NodeMut::AlterDomainStmt(n) => Ok(NodeEnum::AlterDomainStmt(Box::new(
461 n.as_ref().ok_or(err)?.clone(),
462 ))),
463 NodeMut::SetOperationStmt(n) => Ok(NodeEnum::SetOperationStmt(Box::new(
464 n.as_ref().ok_or(err)?.clone(),
465 ))),
466 NodeMut::GrantStmt(n) => Ok(NodeEnum::GrantStmt(n.as_ref().ok_or(err)?.clone())),
467 NodeMut::GrantRoleStmt(n) => {
468 Ok(NodeEnum::GrantRoleStmt(n.as_ref().ok_or(err)?.clone()))
469 }
470 NodeMut::AlterDefaultPrivilegesStmt(n) => Ok(NodeEnum::AlterDefaultPrivilegesStmt(
471 n.as_ref().ok_or(err)?.clone(),
472 )),
473 NodeMut::ClosePortalStmt(n) => {
474 Ok(NodeEnum::ClosePortalStmt(n.as_ref().ok_or(err)?.clone()))
475 }
476 NodeMut::ClusterStmt(n) => {
477 Ok(NodeEnum::ClusterStmt(n.as_ref().ok_or(err)?.clone()))
478 }
479 NodeMut::CopyStmt(n) => {
480 Ok(NodeEnum::CopyStmt(Box::new(n.as_ref().ok_or(err)?.clone())))
481 }
482 NodeMut::CreateStmt(n) => Ok(NodeEnum::CreateStmt(n.as_ref().ok_or(err)?.clone())),
483 NodeMut::DefineStmt(n) => Ok(NodeEnum::DefineStmt(n.as_ref().ok_or(err)?.clone())),
484 NodeMut::DropStmt(n) => Ok(NodeEnum::DropStmt(n.as_ref().ok_or(err)?.clone())),
485 NodeMut::TruncateStmt(n) => {
486 Ok(NodeEnum::TruncateStmt(n.as_ref().ok_or(err)?.clone()))
487 }
488 NodeMut::CommentStmt(n) => Ok(NodeEnum::CommentStmt(Box::new(
489 n.as_ref().ok_or(err)?.clone(),
490 ))),
491 NodeMut::FetchStmt(n) => Ok(NodeEnum::FetchStmt(n.as_ref().ok_or(err)?.clone())),
492 NodeMut::IndexStmt(n) => Ok(NodeEnum::IndexStmt(Box::new(
493 n.as_ref().ok_or(err)?.clone(),
494 ))),
495 NodeMut::CreateFunctionStmt(n) => Ok(NodeEnum::CreateFunctionStmt(Box::new(
496 n.as_ref().ok_or(err)?.clone(),
497 ))),
498 NodeMut::AlterFunctionStmt(n) => {
499 Ok(NodeEnum::AlterFunctionStmt(n.as_ref().ok_or(err)?.clone()))
500 }
501 NodeMut::DoStmt(n) => Ok(NodeEnum::DoStmt(n.as_ref().ok_or(err)?.clone())),
502 NodeMut::RenameStmt(n) => Ok(NodeEnum::RenameStmt(Box::new(
503 n.as_ref().ok_or(err)?.clone(),
504 ))),
505 NodeMut::RuleStmt(n) => {
506 Ok(NodeEnum::RuleStmt(Box::new(n.as_ref().ok_or(err)?.clone())))
507 }
508 NodeMut::NotifyStmt(n) => Ok(NodeEnum::NotifyStmt(n.as_ref().ok_or(err)?.clone())),
509 NodeMut::ListenStmt(n) => Ok(NodeEnum::ListenStmt(n.as_ref().ok_or(err)?.clone())),
510 NodeMut::UnlistenStmt(n) => {
511 Ok(NodeEnum::UnlistenStmt(n.as_ref().ok_or(err)?.clone()))
512 }
513 NodeMut::TransactionStmt(n) => {
514 Ok(NodeEnum::TransactionStmt(n.as_ref().ok_or(err)?.clone()))
515 }
516 NodeMut::ViewStmt(n) => {
517 Ok(NodeEnum::ViewStmt(Box::new(n.as_ref().ok_or(err)?.clone())))
518 }
519 NodeMut::LoadStmt(n) => Ok(NodeEnum::LoadStmt(n.as_ref().ok_or(err)?.clone())),
520 NodeMut::CreateDomainStmt(n) => Ok(NodeEnum::CreateDomainStmt(Box::new(
521 n.as_ref().ok_or(err)?.clone(),
522 ))),
523 NodeMut::CreatedbStmt(n) => {
524 Ok(NodeEnum::CreatedbStmt(n.as_ref().ok_or(err)?.clone()))
525 }
526 NodeMut::DropdbStmt(n) => Ok(NodeEnum::DropdbStmt(n.as_ref().ok_or(err)?.clone())),
527 NodeMut::VacuumStmt(n) => Ok(NodeEnum::VacuumStmt(n.as_ref().ok_or(err)?.clone())),
528 NodeMut::ExplainStmt(n) => Ok(NodeEnum::ExplainStmt(Box::new(
529 n.as_ref().ok_or(err)?.clone(),
530 ))),
531 NodeMut::CreateTableAsStmt(n) => Ok(NodeEnum::CreateTableAsStmt(Box::new(
532 n.as_ref().ok_or(err)?.clone(),
533 ))),
534 NodeMut::CreateSeqStmt(n) => {
535 Ok(NodeEnum::CreateSeqStmt(n.as_ref().ok_or(err)?.clone()))
536 }
537 NodeMut::AlterSeqStmt(n) => {
538 Ok(NodeEnum::AlterSeqStmt(n.as_ref().ok_or(err)?.clone()))
539 }
540 NodeMut::VariableSetStmt(n) => {
541 Ok(NodeEnum::VariableSetStmt(n.as_ref().ok_or(err)?.clone()))
542 }
543 NodeMut::VariableShowStmt(n) => {
544 Ok(NodeEnum::VariableShowStmt(n.as_ref().ok_or(err)?.clone()))
545 }
546 NodeMut::DiscardStmt(n) => {
547 Ok(NodeEnum::DiscardStmt(n.as_ref().ok_or(err)?.clone()))
548 }
549 NodeMut::CreateTrigStmt(n) => Ok(NodeEnum::CreateTrigStmt(Box::new(
550 n.as_ref().ok_or(err)?.clone(),
551 ))),
552 NodeMut::CreatePlangStmt(n) => {
553 Ok(NodeEnum::CreatePlangStmt(n.as_ref().ok_or(err)?.clone()))
554 }
555 NodeMut::CreateRoleStmt(n) => {
556 Ok(NodeEnum::CreateRoleStmt(n.as_ref().ok_or(err)?.clone()))
557 }
558 NodeMut::AlterRoleStmt(n) => {
559 Ok(NodeEnum::AlterRoleStmt(n.as_ref().ok_or(err)?.clone()))
560 }
561 NodeMut::DropRoleStmt(n) => {
562 Ok(NodeEnum::DropRoleStmt(n.as_ref().ok_or(err)?.clone()))
563 }
564 NodeMut::LockStmt(n) => Ok(NodeEnum::LockStmt(n.as_ref().ok_or(err)?.clone())),
565 NodeMut::ConstraintsSetStmt(n) => {
566 Ok(NodeEnum::ConstraintsSetStmt(n.as_ref().ok_or(err)?.clone()))
567 }
568 NodeMut::ReindexStmt(n) => {
569 Ok(NodeEnum::ReindexStmt(n.as_ref().ok_or(err)?.clone()))
570 }
571 NodeMut::CheckPointStmt(n) => {
572 Ok(NodeEnum::CheckPointStmt(n.as_ref().ok_or(err)?.clone()))
573 }
574 NodeMut::CreateSchemaStmt(n) => {
575 Ok(NodeEnum::CreateSchemaStmt(n.as_ref().ok_or(err)?.clone()))
576 }
577 NodeMut::AlterDatabaseStmt(n) => {
578 Ok(NodeEnum::AlterDatabaseStmt(n.as_ref().ok_or(err)?.clone()))
579 }
580 NodeMut::AlterDatabaseSetStmt(n) => Ok(NodeEnum::AlterDatabaseSetStmt(
581 n.as_ref().ok_or(err)?.clone(),
582 )),
583 NodeMut::AlterRoleSetStmt(n) => {
584 Ok(NodeEnum::AlterRoleSetStmt(n.as_ref().ok_or(err)?.clone()))
585 }
586 NodeMut::CreateConversionStmt(n) => Ok(NodeEnum::CreateConversionStmt(
587 n.as_ref().ok_or(err)?.clone(),
588 )),
589 NodeMut::CreateCastStmt(n) => {
590 Ok(NodeEnum::CreateCastStmt(n.as_ref().ok_or(err)?.clone()))
591 }
592 NodeMut::CreateOpClassStmt(n) => {
593 Ok(NodeEnum::CreateOpClassStmt(n.as_ref().ok_or(err)?.clone()))
594 }
595 NodeMut::CreateOpFamilyStmt(n) => {
596 Ok(NodeEnum::CreateOpFamilyStmt(n.as_ref().ok_or(err)?.clone()))
597 }
598 NodeMut::AlterOpFamilyStmt(n) => {
599 Ok(NodeEnum::AlterOpFamilyStmt(n.as_ref().ok_or(err)?.clone()))
600 }
601 NodeMut::PrepareStmt(n) => Ok(NodeEnum::PrepareStmt(Box::new(
602 n.as_ref().ok_or(err)?.clone(),
603 ))),
604 NodeMut::ExecuteStmt(n) => {
605 Ok(NodeEnum::ExecuteStmt(n.as_ref().ok_or(err)?.clone()))
606 }
607 NodeMut::DeallocateStmt(n) => {
608 Ok(NodeEnum::DeallocateStmt(n.as_ref().ok_or(err)?.clone()))
609 }
610 NodeMut::DeclareCursorStmt(n) => Ok(NodeEnum::DeclareCursorStmt(Box::new(
611 n.as_ref().ok_or(err)?.clone(),
612 ))),
613 NodeMut::CreateTableSpaceStmt(n) => Ok(NodeEnum::CreateTableSpaceStmt(
614 n.as_ref().ok_or(err)?.clone(),
615 )),
616 NodeMut::DropTableSpaceStmt(n) => {
617 Ok(NodeEnum::DropTableSpaceStmt(n.as_ref().ok_or(err)?.clone()))
618 }
619 NodeMut::AlterObjectDependsStmt(n) => Ok(NodeEnum::AlterObjectDependsStmt(
620 Box::new(n.as_ref().ok_or(err)?.clone()),
621 )),
622 NodeMut::AlterObjectSchemaStmt(n) => Ok(NodeEnum::AlterObjectSchemaStmt(Box::new(
623 n.as_ref().ok_or(err)?.clone(),
624 ))),
625 NodeMut::AlterOwnerStmt(n) => Ok(NodeEnum::AlterOwnerStmt(Box::new(
626 n.as_ref().ok_or(err)?.clone(),
627 ))),
628 NodeMut::AlterOperatorStmt(n) => {
629 Ok(NodeEnum::AlterOperatorStmt(n.as_ref().ok_or(err)?.clone()))
630 }
631 NodeMut::AlterTypeStmt(n) => {
632 Ok(NodeEnum::AlterTypeStmt(n.as_ref().ok_or(err)?.clone()))
633 }
634 NodeMut::AtalterConstraint(n) => {
635 Ok(NodeEnum::AtalterConstraint(n.as_ref().ok_or(err)?.clone()))
636 }
637 NodeMut::DropOwnedStmt(n) => {
638 Ok(NodeEnum::DropOwnedStmt(n.as_ref().ok_or(err)?.clone()))
639 }
640 NodeMut::ReassignOwnedStmt(n) => {
641 Ok(NodeEnum::ReassignOwnedStmt(n.as_ref().ok_or(err)?.clone()))
642 }
643 NodeMut::CompositeTypeStmt(n) => {
644 Ok(NodeEnum::CompositeTypeStmt(n.as_ref().ok_or(err)?.clone()))
645 }
646 NodeMut::CreateEnumStmt(n) => {
647 Ok(NodeEnum::CreateEnumStmt(n.as_ref().ok_or(err)?.clone()))
648 }
649 NodeMut::CreateRangeStmt(n) => {
650 Ok(NodeEnum::CreateRangeStmt(n.as_ref().ok_or(err)?.clone()))
651 }
652 NodeMut::AlterEnumStmt(n) => {
653 Ok(NodeEnum::AlterEnumStmt(n.as_ref().ok_or(err)?.clone()))
654 }
655 NodeMut::AlterTsdictionaryStmt(n) => Ok(NodeEnum::AlterTsdictionaryStmt(
656 n.as_ref().ok_or(err)?.clone(),
657 )),
658 NodeMut::AlterTsconfigurationStmt(n) => Ok(NodeEnum::AlterTsconfigurationStmt(
659 n.as_ref().ok_or(err)?.clone(),
660 )),
661 NodeMut::CreateFdwStmt(n) => {
662 Ok(NodeEnum::CreateFdwStmt(n.as_ref().ok_or(err)?.clone()))
663 }
664 NodeMut::AlterFdwStmt(n) => {
665 Ok(NodeEnum::AlterFdwStmt(n.as_ref().ok_or(err)?.clone()))
666 }
667 NodeMut::CreateForeignServerStmt(n) => Ok(NodeEnum::CreateForeignServerStmt(
668 n.as_ref().ok_or(err)?.clone(),
669 )),
670 NodeMut::AlterForeignServerStmt(n) => Ok(NodeEnum::AlterForeignServerStmt(
671 n.as_ref().ok_or(err)?.clone(),
672 )),
673 NodeMut::CreateUserMappingStmt(n) => Ok(NodeEnum::CreateUserMappingStmt(
674 n.as_ref().ok_or(err)?.clone(),
675 )),
676 NodeMut::AlterUserMappingStmt(n) => Ok(NodeEnum::AlterUserMappingStmt(
677 n.as_ref().ok_or(err)?.clone(),
678 )),
679 NodeMut::DropUserMappingStmt(n) => Ok(NodeEnum::DropUserMappingStmt(
680 n.as_ref().ok_or(err)?.clone(),
681 )),
682 NodeMut::AlterTableSpaceOptionsStmt(n) => Ok(NodeEnum::AlterTableSpaceOptionsStmt(
683 n.as_ref().ok_or(err)?.clone(),
684 )),
685 NodeMut::AlterTableMoveAllStmt(n) => Ok(NodeEnum::AlterTableMoveAllStmt(
686 n.as_ref().ok_or(err)?.clone(),
687 )),
688 NodeMut::SecLabelStmt(n) => Ok(NodeEnum::SecLabelStmt(Box::new(
689 n.as_ref().ok_or(err)?.clone(),
690 ))),
691 NodeMut::CreateForeignTableStmt(n) => Ok(NodeEnum::CreateForeignTableStmt(
692 n.as_ref().ok_or(err)?.clone(),
693 )),
694 NodeMut::ImportForeignSchemaStmt(n) => Ok(NodeEnum::ImportForeignSchemaStmt(
695 n.as_ref().ok_or(err)?.clone(),
696 )),
697 NodeMut::CreateExtensionStmt(n) => Ok(NodeEnum::CreateExtensionStmt(
698 n.as_ref().ok_or(err)?.clone(),
699 )),
700 NodeMut::AlterExtensionStmt(n) => {
701 Ok(NodeEnum::AlterExtensionStmt(n.as_ref().ok_or(err)?.clone()))
702 }
703 NodeMut::AlterExtensionContentsStmt(n) => Ok(NodeEnum::AlterExtensionContentsStmt(
704 Box::new(n.as_ref().ok_or(err)?.clone()),
705 )),
706 NodeMut::CreateEventTrigStmt(n) => Ok(NodeEnum::CreateEventTrigStmt(
707 n.as_ref().ok_or(err)?.clone(),
708 )),
709 NodeMut::AlterEventTrigStmt(n) => {
710 Ok(NodeEnum::AlterEventTrigStmt(n.as_ref().ok_or(err)?.clone()))
711 }
712 NodeMut::RefreshMatViewStmt(n) => {
713 Ok(NodeEnum::RefreshMatViewStmt(n.as_ref().ok_or(err)?.clone()))
714 }
715 NodeMut::ReplicaIdentityStmt(n) => Ok(NodeEnum::ReplicaIdentityStmt(
716 n.as_ref().ok_or(err)?.clone(),
717 )),
718 NodeMut::AlterSystemStmt(n) => {
719 Ok(NodeEnum::AlterSystemStmt(n.as_ref().ok_or(err)?.clone()))
720 }
721 NodeMut::CreatePolicyStmt(n) => Ok(NodeEnum::CreatePolicyStmt(Box::new(
722 n.as_ref().ok_or(err)?.clone(),
723 ))),
724 NodeMut::AlterPolicyStmt(n) => Ok(NodeEnum::AlterPolicyStmt(Box::new(
725 n.as_ref().ok_or(err)?.clone(),
726 ))),
727 NodeMut::CreateTransformStmt(n) => Ok(NodeEnum::CreateTransformStmt(
728 n.as_ref().ok_or(err)?.clone(),
729 )),
730 NodeMut::CreateAmStmt(n) => {
731 Ok(NodeEnum::CreateAmStmt(n.as_ref().ok_or(err)?.clone()))
732 }
733 NodeMut::CreatePublicationStmt(n) => Ok(NodeEnum::CreatePublicationStmt(
734 n.as_ref().ok_or(err)?.clone(),
735 )),
736 NodeMut::AlterPublicationStmt(n) => Ok(NodeEnum::AlterPublicationStmt(
737 n.as_ref().ok_or(err)?.clone(),
738 )),
739 NodeMut::CreateSubscriptionStmt(n) => Ok(NodeEnum::CreateSubscriptionStmt(
740 n.as_ref().ok_or(err)?.clone(),
741 )),
742 NodeMut::AlterSubscriptionStmt(n) => Ok(NodeEnum::AlterSubscriptionStmt(
743 n.as_ref().ok_or(err)?.clone(),
744 )),
745 NodeMut::DropSubscriptionStmt(n) => Ok(NodeEnum::DropSubscriptionStmt(
746 n.as_ref().ok_or(err)?.clone(),
747 )),
748 NodeMut::CreateStatsStmt(n) => {
749 Ok(NodeEnum::CreateStatsStmt(n.as_ref().ok_or(err)?.clone()))
750 }
751 NodeMut::AlterCollationStmt(n) => {
752 Ok(NodeEnum::AlterCollationStmt(n.as_ref().ok_or(err)?.clone()))
753 }
754 NodeMut::CallStmt(n) => {
755 Ok(NodeEnum::CallStmt(Box::new(n.as_ref().ok_or(err)?.clone())))
756 }
757 NodeMut::AlterStatsStmt(n) => Ok(NodeEnum::AlterStatsStmt(Box::new(
758 n.as_ref().ok_or(err)?.clone(),
759 ))),
760 NodeMut::AExpr(n) => Ok(NodeEnum::AExpr(Box::new(n.as_ref().ok_or(err)?.clone()))),
761 NodeMut::ColumnRef(n) => Ok(NodeEnum::ColumnRef(n.as_ref().ok_or(err)?.clone())),
762 NodeMut::ParamRef(n) => Ok(NodeEnum::ParamRef(n.as_ref().ok_or(err)?.clone())),
763 NodeMut::AConst(n) => Ok(NodeEnum::AConst(n.as_ref().ok_or(err)?.clone())),
764 NodeMut::FuncCall(n) => {
765 Ok(NodeEnum::FuncCall(Box::new(n.as_ref().ok_or(err)?.clone())))
766 }
767 NodeMut::AStar(n) => Ok(NodeEnum::AStar(n.as_ref().ok_or(err)?.clone())),
768 NodeMut::AIndices(n) => {
769 Ok(NodeEnum::AIndices(Box::new(n.as_ref().ok_or(err)?.clone())))
770 }
771 NodeMut::AIndirection(n) => Ok(NodeEnum::AIndirection(Box::new(
772 n.as_ref().ok_or(err)?.clone(),
773 ))),
774 NodeMut::AArrayExpr(n) => Ok(NodeEnum::AArrayExpr(n.as_ref().ok_or(err)?.clone())),
775 NodeMut::ResTarget(n) => Ok(NodeEnum::ResTarget(Box::new(
776 n.as_ref().ok_or(err)?.clone(),
777 ))),
778 NodeMut::MultiAssignRef(n) => Ok(NodeEnum::MultiAssignRef(Box::new(
779 n.as_ref().ok_or(err)?.clone(),
780 ))),
781 NodeMut::TypeCast(n) => {
782 Ok(NodeEnum::TypeCast(Box::new(n.as_ref().ok_or(err)?.clone())))
783 }
784 NodeMut::CollateClause(n) => Ok(NodeEnum::CollateClause(Box::new(
785 n.as_ref().ok_or(err)?.clone(),
786 ))),
787 NodeMut::SortBy(n) => {
788 Ok(NodeEnum::SortBy(Box::new(n.as_ref().ok_or(err)?.clone())))
789 }
790 NodeMut::WindowDef(n) => Ok(NodeEnum::WindowDef(Box::new(
791 n.as_ref().ok_or(err)?.clone(),
792 ))),
793 NodeMut::RangeSubselect(n) => Ok(NodeEnum::RangeSubselect(Box::new(
794 n.as_ref().ok_or(err)?.clone(),
795 ))),
796 NodeMut::RangeFunction(n) => {
797 Ok(NodeEnum::RangeFunction(n.as_ref().ok_or(err)?.clone()))
798 }
799 NodeMut::RangeTableSample(n) => Ok(NodeEnum::RangeTableSample(Box::new(
800 n.as_ref().ok_or(err)?.clone(),
801 ))),
802 NodeMut::RangeTableFunc(n) => Ok(NodeEnum::RangeTableFunc(Box::new(
803 n.as_ref().ok_or(err)?.clone(),
804 ))),
805 NodeMut::RangeTableFuncCol(n) => Ok(NodeEnum::RangeTableFuncCol(Box::new(
806 n.as_ref().ok_or(err)?.clone(),
807 ))),
808 NodeMut::TypeName(n) => Ok(NodeEnum::TypeName(n.as_ref().ok_or(err)?.clone())),
809 NodeMut::ColumnDef(n) => Ok(NodeEnum::ColumnDef(Box::new(
810 n.as_ref().ok_or(err)?.clone(),
811 ))),
812 NodeMut::IndexElem(n) => Ok(NodeEnum::IndexElem(Box::new(
813 n.as_ref().ok_or(err)?.clone(),
814 ))),
815 NodeMut::Constraint(n) => Ok(NodeEnum::Constraint(Box::new(
816 n.as_ref().ok_or(err)?.clone(),
817 ))),
818 NodeMut::DefElem(n) => {
819 Ok(NodeEnum::DefElem(Box::new(n.as_ref().ok_or(err)?.clone())))
820 }
821 NodeMut::RangeTblEntry(n) => Ok(NodeEnum::RangeTblEntry(Box::new(
822 n.as_ref().ok_or(err)?.clone(),
823 ))),
824 NodeMut::RangeTblFunction(n) => Ok(NodeEnum::RangeTblFunction(Box::new(
825 n.as_ref().ok_or(err)?.clone(),
826 ))),
827 NodeMut::TableSampleClause(n) => Ok(NodeEnum::TableSampleClause(Box::new(
828 n.as_ref().ok_or(err)?.clone(),
829 ))),
830 NodeMut::WithCheckOption(n) => Ok(NodeEnum::WithCheckOption(Box::new(
831 n.as_ref().ok_or(err)?.clone(),
832 ))),
833 NodeMut::SortGroupClause(n) => {
834 Ok(NodeEnum::SortGroupClause(n.as_ref().ok_or(err)?.clone()))
835 }
836 NodeMut::GroupingSet(n) => {
837 Ok(NodeEnum::GroupingSet(n.as_ref().ok_or(err)?.clone()))
838 }
839 NodeMut::WindowClause(n) => Ok(NodeEnum::WindowClause(Box::new(
840 n.as_ref().ok_or(err)?.clone(),
841 ))),
842 NodeMut::ObjectWithArgs(n) => {
843 Ok(NodeEnum::ObjectWithArgs(n.as_ref().ok_or(err)?.clone()))
844 }
845 NodeMut::AccessPriv(n) => Ok(NodeEnum::AccessPriv(n.as_ref().ok_or(err)?.clone())),
846 NodeMut::CreateOpClassItem(n) => {
847 Ok(NodeEnum::CreateOpClassItem(n.as_ref().ok_or(err)?.clone()))
848 }
849 NodeMut::TableLikeClause(n) => {
850 Ok(NodeEnum::TableLikeClause(n.as_ref().ok_or(err)?.clone()))
851 }
852 NodeMut::FunctionParameter(n) => Ok(NodeEnum::FunctionParameter(Box::new(
853 n.as_ref().ok_or(err)?.clone(),
854 ))),
855 NodeMut::LockingClause(n) => {
856 Ok(NodeEnum::LockingClause(n.as_ref().ok_or(err)?.clone()))
857 }
858 NodeMut::RowMarkClause(n) => {
859 Ok(NodeEnum::RowMarkClause(n.as_ref().ok_or(err)?.clone()))
860 }
861 NodeMut::XmlSerialize(n) => Ok(NodeEnum::XmlSerialize(Box::new(
862 n.as_ref().ok_or(err)?.clone(),
863 ))),
864 NodeMut::WithClause(n) => Ok(NodeEnum::WithClause(n.as_ref().ok_or(err)?.clone())),
865 NodeMut::InferClause(n) => Ok(NodeEnum::InferClause(Box::new(
866 n.as_ref().ok_or(err)?.clone(),
867 ))),
868 NodeMut::OnConflictClause(n) => Ok(NodeEnum::OnConflictClause(Box::new(
869 n.as_ref().ok_or(err)?.clone(),
870 ))),
871 NodeMut::CommonTableExpr(n) => Ok(NodeEnum::CommonTableExpr(Box::new(
872 n.as_ref().ok_or(err)?.clone(),
873 ))),
874 NodeMut::RoleSpec(n) => Ok(NodeEnum::RoleSpec(n.as_ref().ok_or(err)?.clone())),
875 NodeMut::TriggerTransition(n) => {
876 Ok(NodeEnum::TriggerTransition(n.as_ref().ok_or(err)?.clone()))
877 }
878 NodeMut::PartitionElem(n) => Ok(NodeEnum::PartitionElem(Box::new(
879 n.as_ref().ok_or(err)?.clone(),
880 ))),
881 NodeMut::PartitionSpec(n) => {
882 Ok(NodeEnum::PartitionSpec(n.as_ref().ok_or(err)?.clone()))
883 }
884 NodeMut::PartitionBoundSpec(n) => {
885 Ok(NodeEnum::PartitionBoundSpec(n.as_ref().ok_or(err)?.clone()))
886 }
887 NodeMut::PartitionRangeDatum(n) => Ok(NodeEnum::PartitionRangeDatum(Box::new(
888 n.as_ref().ok_or(err)?.clone(),
889 ))),
890 NodeMut::PartitionCmd(n) => {
891 Ok(NodeEnum::PartitionCmd(n.as_ref().ok_or(err)?.clone()))
892 }
893 NodeMut::VacuumRelation(n) => {
894 Ok(NodeEnum::VacuumRelation(n.as_ref().ok_or(err)?.clone()))
895 }
896 NodeMut::InlineCodeBlock(n) => {
897 Ok(NodeEnum::InlineCodeBlock(n.as_ref().ok_or(err)?.clone()))
898 }
899 NodeMut::CallContext(n) => {
900 Ok(NodeEnum::CallContext(n.as_ref().ok_or(err)?.clone()))
901 }
902 NodeMut::Integer(n) => Ok(NodeEnum::Integer(n.as_ref().ok_or(err)?.clone())),
903 NodeMut::Float(n) => Ok(NodeEnum::Float(n.as_ref().ok_or(err)?.clone())),
904 NodeMut::Boolean(n) => Ok(NodeEnum::Boolean(n.as_ref().ok_or(err)?.clone())),
905 NodeMut::String(n) => Ok(NodeEnum::String(n.as_ref().ok_or(err)?.clone())),
906 NodeMut::BitString(n) => Ok(NodeEnum::BitString(n.as_ref().ok_or(err)?.clone())),
907 NodeMut::List(n) => Ok(NodeEnum::List(n.as_ref().ok_or(err)?.clone())),
908 NodeMut::IntList(n) => Ok(NodeEnum::IntList(n.as_ref().ok_or(err)?.clone())),
909 NodeMut::OidList(n) => Ok(NodeEnum::OidList(n.as_ref().ok_or(err)?.clone())),
910 NodeMut::MergeStmt(n) => Ok(NodeEnum::MergeStmt(Box::new(
911 n.as_ref().ok_or(err)?.clone(),
912 ))),
913 NodeMut::MergeAction(n) => Ok(NodeEnum::MergeAction(Box::new(
914 n.as_ref().ok_or(err)?.clone(),
915 ))),
916 NodeMut::AlterDatabaseRefreshCollStmt(n) => Ok(
917 NodeEnum::AlterDatabaseRefreshCollStmt(n.as_ref().ok_or(err)?.clone()),
918 ),
919 NodeMut::ReturnStmt(n) => Ok(NodeEnum::ReturnStmt(Box::new(
920 n.as_ref().ok_or(err)?.clone(),
921 ))),
922 NodeMut::ReturningClause(n) => {
923 Ok(NodeEnum::ReturningClause(n.as_ref().ok_or(err)?.clone()))
924 }
925 NodeMut::ReturningExpr(n) => Ok(NodeEnum::ReturningExpr(Box::new(
926 n.as_ref().ok_or(err)?.clone(),
927 ))),
928 NodeMut::ReturningOption(n) => {
929 Ok(NodeEnum::ReturningOption(n.as_ref().ok_or(err)?.clone()))
930 }
931 NodeMut::PlassignStmt(n) => Ok(NodeEnum::PlassignStmt(Box::new(
932 n.as_ref().ok_or(err)?.clone(),
933 ))),
934 NodeMut::StatsElem(n) => Ok(NodeEnum::StatsElem(Box::new(
935 n.as_ref().ok_or(err)?.clone(),
936 ))),
937 NodeMut::CtesearchClause(n) => {
938 Ok(NodeEnum::CtesearchClause(n.as_ref().ok_or(err)?.clone()))
939 }
940 NodeMut::CtecycleClause(n) => Ok(NodeEnum::CtecycleClause(Box::new(
941 n.as_ref().ok_or(err)?.clone(),
942 ))),
943 NodeMut::MergeWhenClause(n) => Ok(NodeEnum::MergeWhenClause(Box::new(
944 n.as_ref().ok_or(err)?.clone(),
945 ))),
946 NodeMut::PublicationObjSpec(n) => Ok(NodeEnum::PublicationObjSpec(Box::new(
947 n.as_ref().ok_or(err)?.clone(),
948 ))),
949 NodeMut::PublicationTable(n) => Ok(NodeEnum::PublicationTable(Box::new(
950 n.as_ref().ok_or(err)?.clone(),
951 ))),
952 NodeMut::JsonFormat(n) => Ok(NodeEnum::JsonFormat(n.as_ref().ok_or(err)?.clone())),
953 NodeMut::JsonReturning(n) => {
954 Ok(NodeEnum::JsonReturning(n.as_ref().ok_or(err)?.clone()))
955 }
956 NodeMut::JsonValueExpr(n) => Ok(NodeEnum::JsonValueExpr(Box::new(
957 n.as_ref().ok_or(err)?.clone(),
958 ))),
959 NodeMut::JsonConstructorExpr(n) => Ok(NodeEnum::JsonConstructorExpr(Box::new(
960 n.as_ref().ok_or(err)?.clone(),
961 ))),
962 NodeMut::JsonIsPredicate(n) => Ok(NodeEnum::JsonIsPredicate(Box::new(
963 n.as_ref().ok_or(err)?.clone(),
964 ))),
965 NodeMut::JsonOutput(n) => Ok(NodeEnum::JsonOutput(n.as_ref().ok_or(err)?.clone())),
966 NodeMut::JsonKeyValue(n) => Ok(NodeEnum::JsonKeyValue(Box::new(
967 n.as_ref().ok_or(err)?.clone(),
968 ))),
969 NodeMut::JsonObjectConstructor(n) => Ok(NodeEnum::JsonObjectConstructor(
970 n.as_ref().ok_or(err)?.clone(),
971 )),
972 NodeMut::JsonArrayConstructor(n) => Ok(NodeEnum::JsonArrayConstructor(
973 n.as_ref().ok_or(err)?.clone(),
974 )),
975 NodeMut::JsonArrayQueryConstructor(n) => Ok(NodeEnum::JsonArrayQueryConstructor(
976 Box::new(n.as_ref().ok_or(err)?.clone()),
977 )),
978 NodeMut::JsonAggConstructor(n) => Ok(NodeEnum::JsonAggConstructor(Box::new(
979 n.as_ref().ok_or(err)?.clone(),
980 ))),
981 NodeMut::JsonObjectAgg(n) => Ok(NodeEnum::JsonObjectAgg(Box::new(
982 n.as_ref().ok_or(err)?.clone(),
983 ))),
984 NodeMut::JsonArrayAgg(n) => Ok(NodeEnum::JsonArrayAgg(Box::new(
985 n.as_ref().ok_or(err)?.clone(),
986 ))),
987 NodeMut::RtepermissionInfo(n) => {
988 Ok(NodeEnum::RtepermissionInfo(n.as_ref().ok_or(err)?.clone()))
989 }
990 NodeMut::WindowFuncRunCondition(n) => Ok(NodeEnum::WindowFuncRunCondition(
991 Box::new(n.as_ref().ok_or(err)?.clone()),
992 )),
993 NodeMut::MergeSupportFunc(n) => Ok(NodeEnum::MergeSupportFunc(Box::new(
994 n.as_ref().ok_or(err)?.clone(),
995 ))),
996 NodeMut::JsonBehavior(n) => Ok(NodeEnum::JsonBehavior(Box::new(
997 n.as_ref().ok_or(err)?.clone(),
998 ))),
999 NodeMut::JsonExpr(n) => {
1000 Ok(NodeEnum::JsonExpr(Box::new(n.as_ref().ok_or(err)?.clone())))
1001 }
1002 NodeMut::JsonTablePath(n) => {
1003 Ok(NodeEnum::JsonTablePath(n.as_ref().ok_or(err)?.clone()))
1004 }
1005 NodeMut::JsonTablePathScan(n) => Ok(NodeEnum::JsonTablePathScan(Box::new(
1006 n.as_ref().ok_or(err)?.clone(),
1007 ))),
1008 NodeMut::JsonTableSiblingJoin(n) => Ok(NodeEnum::JsonTableSiblingJoin(Box::new(
1009 n.as_ref().ok_or(err)?.clone(),
1010 ))),
1011 NodeMut::JsonArgument(n) => Ok(NodeEnum::JsonArgument(Box::new(
1012 n.as_ref().ok_or(err)?.clone(),
1013 ))),
1014 NodeMut::JsonFuncExpr(n) => Ok(NodeEnum::JsonFuncExpr(Box::new(
1015 n.as_ref().ok_or(err)?.clone(),
1016 ))),
1017 NodeMut::JsonTablePathSpec(n) => Ok(NodeEnum::JsonTablePathSpec(Box::new(
1018 n.as_ref().ok_or(err)?.clone(),
1019 ))),
1020 NodeMut::JsonTable(n) => Ok(NodeEnum::JsonTable(Box::new(
1021 n.as_ref().ok_or(err)?.clone(),
1022 ))),
1023 NodeMut::JsonTableColumn(n) => Ok(NodeEnum::JsonTableColumn(Box::new(
1024 n.as_ref().ok_or(err)?.clone(),
1025 ))),
1026 NodeMut::JsonParseExpr(n) => Ok(NodeEnum::JsonParseExpr(Box::new(
1027 n.as_ref().ok_or(err)?.clone(),
1028 ))),
1029 NodeMut::JsonScalarExpr(n) => Ok(NodeEnum::JsonScalarExpr(Box::new(
1030 n.as_ref().ok_or(err)?.clone(),
1031 ))),
1032 NodeMut::JsonSerializeExpr(n) => Ok(NodeEnum::JsonSerializeExpr(Box::new(
1033 n.as_ref().ok_or(err)?.clone(),
1034 ))),
1035 }
1036 }
1037 }
1038}