1use crate::*;
2
3pub use protobuf::node::Node as NodeEnum;
4use std::collections::VecDeque;
5
6#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, serde::Serialize)]
7pub enum Context {
8 None,
9 Select,
10 DML,
11 DDL,
12 Call,
13}
14
15impl NodeEnum {
16 pub fn deparse(&self) -> Result<String> {
17 crate::deparse(&protobuf::ParseResult {
18 version: crate::bindings::PG_VERSION_NUM as i32,
19 stmts: vec![protobuf::RawStmt { stmt: Some(Box::new(Node { node: Some(self.clone()) })), stmt_location: 0, stmt_len: 0 }],
20 })
21 }
22
23 pub fn nodes(&self) -> Vec<(NodeRef<'_>, i32, Context, bool)> {
24 let mut iter = VecDeque::new();
25 iter.push_front((self.to_ref(), 0, Context::None, false));
26 let mut nodes = Vec::new();
27 while let Some((node, depth, context, has_filter_columns)) = iter.pop_front() {
28 let depth = depth + 1;
29 match node {
30 NodeRef::SelectStmt(s) => {
34 s.target_list.iter().for_each(|n| {
35 if let Some(n) = n.node.as_ref() {
36 iter.push_back((n.to_ref(), depth, Context::Select, false));
37 }
38 });
39 if let Some(n) = &s.where_clause {
40 if let Some(n) = n.node.as_ref() {
41 iter.push_back((n.to_ref(), depth, Context::Select, true));
42 }
43 }
44 s.sort_clause.iter().for_each(|n| {
45 if let Some(n) = n.node.as_ref() {
46 iter.push_back((n.to_ref(), depth, Context::Select, false));
47 }
48 });
49 s.group_clause.iter().for_each(|n| {
50 if let Some(n) = n.node.as_ref() {
51 iter.push_back((n.to_ref(), depth, Context::Select, false));
52 }
53 });
54 if let Some(n) = &s.having_clause {
55 if let Some(n) = n.node.as_ref() {
56 iter.push_back((n.to_ref(), depth, Context::Select, false));
57 }
58 }
59 if let Some(clause) = &s.with_clause {
60 clause.ctes.iter().for_each(|n| {
61 if let Some(n) = n.node.as_ref() {
62 iter.push_back((n.to_ref(), depth, Context::Select, false));
63 }
64 });
65 }
66 match protobuf::SetOperation::try_from(s.op) {
67 Ok(protobuf::SetOperation::SetopNone) => {
68 s.from_clause.iter().for_each(|n| {
69 if let Some(n) = n.node.as_ref() {
70 iter.push_back((n.to_ref(), depth, Context::Select, false));
71 }
72 });
73 }
74 Ok(protobuf::SetOperation::SetopUnion) => {
75 if let Some(left) = s.larg.as_ref() {
76 iter.push_back((left.to_ref(), depth, Context::Select, false));
77 }
78 if let Some(right) = s.rarg.as_ref() {
79 iter.push_back((right.to_ref(), depth, Context::Select, false));
80 }
81 }
82 Ok(protobuf::SetOperation::SetopExcept) => {
83 if let Some(left) = s.larg.as_ref() {
84 iter.push_back((left.to_ref(), depth, Context::Select, false));
85 }
86 if let Some(right) = s.rarg.as_ref() {
87 iter.push_back((right.to_ref(), depth, Context::Select, false));
88 }
89 }
90 Ok(protobuf::SetOperation::SetopIntersect) => {
91 if let Some(left) = s.larg.as_ref() {
92 iter.push_back((left.to_ref(), depth, Context::Select, false));
93 }
94 if let Some(right) = s.rarg.as_ref() {
95 iter.push_back((right.to_ref(), depth, Context::Select, false));
96 }
97 }
98 Ok(protobuf::SetOperation::Undefined) | Err(_) => (),
99 }
100 }
101 NodeRef::InsertStmt(s) => {
102 if let Some(n) = &s.select_stmt {
103 if let Some(n) = n.node.as_ref() {
104 iter.push_back((n.to_ref(), depth, Context::DML, false));
105 }
106 }
107 if let Some(rel) = s.relation.as_ref() {
108 iter.push_back((rel.to_ref(), depth, Context::DML, false));
109 }
110 if let Some(clause) = &s.with_clause {
111 clause.ctes.iter().for_each(|n| {
112 if let Some(n) = n.node.as_ref() {
113 iter.push_back((n.to_ref(), depth, Context::DML, false));
114 }
115 });
116 }
117 if let Some(n) = &s.on_conflict_clause {
118 iter.push_back((n.to_ref(), depth, Context::DML, false));
119 }
120 }
121 NodeRef::UpdateStmt(s) => {
122 s.target_list.iter().for_each(|n| {
123 if let Some(n) = n.node.as_ref() {
124 iter.push_back((n.to_ref(), depth, Context::DML, false));
125 }
126 });
127 s.where_clause.iter().for_each(|n| {
128 if let Some(n) = n.node.as_ref() {
129 iter.push_back((n.to_ref(), depth, Context::DML, true));
130 }
131 });
132 s.from_clause.iter().for_each(|n| {
133 if let Some(n) = n.node.as_ref() {
134 iter.push_back((n.to_ref(), depth, Context::Select, false));
135 }
136 });
137 if let Some(rel) = s.relation.as_ref() {
138 iter.push_back((rel.to_ref(), depth, Context::DML, false));
139 }
140 if let Some(clause) = &s.with_clause {
141 clause.ctes.iter().for_each(|n| {
142 if let Some(n) = n.node.as_ref() {
143 iter.push_back((n.to_ref(), depth, Context::DML, false));
144 }
145 });
146 }
147 }
148 NodeRef::DeleteStmt(s) => {
149 if let Some(n) = &s.where_clause {
150 if let Some(n) = n.node.as_ref() {
151 iter.push_back((n.to_ref(), depth, Context::DML, true));
152 }
153 }
154 if let Some(rel) = s.relation.as_ref() {
155 iter.push_back((rel.to_ref(), depth, Context::DML, false));
156 }
157 if let Some(clause) = &s.with_clause {
158 clause.ctes.iter().for_each(|n| {
159 if let Some(n) = n.node.as_ref() {
160 iter.push_back((n.to_ref(), depth, Context::DML, false));
161 }
162 });
163 }
164 s.using_clause.iter().for_each(|n| {
165 if let Some(n) = n.node.as_ref() {
166 iter.push_back((n.to_ref(), depth, Context::Select, false));
167 }
168 });
169 }
170 NodeRef::MergeStmt(m) => {
171 if let Some(t) = m.relation.as_ref() {
172 iter.push_back((t.to_ref(), depth, Context::DML, false));
173 }
174
175 if let Some(clause) = &m.with_clause {
176 clause.ctes.iter().for_each(|n| {
177 if let Some(n) = n.node.as_ref() {
178 iter.push_back((n.to_ref(), depth, Context::DML, false));
179 }
180 });
181 }
182
183 m.source_relation.iter().for_each(|n| {
184 if let Some(n) = n.node.as_ref() {
185 iter.push_back((n.to_ref(), depth, Context::Select, false));
186 }
187 });
188 m.merge_when_clauses.iter().for_each(|n| {
189 if let Some(n) = n.node.as_ref() {
190 iter.push_back((n.to_ref(), depth, Context::DML, true));
191 }
192 });
193 m.join_condition.iter().for_each(|n| {
194 if let Some(n) = n.node.as_ref() {
195 iter.push_back((n.to_ref(), depth, Context::Select, false));
196 }
197 });
198 }
199 NodeRef::CommonTableExpr(s) => {
200 if let Some(n) = &s.ctequery {
201 if let Some(n) = n.node.as_ref() {
202 iter.push_back((n.to_ref(), depth, context, false));
203 }
204 }
205 }
206 NodeRef::CopyStmt(s) => {
207 if let Some(n) = &s.query {
208 if let Some(n) = n.node.as_ref() {
209 iter.push_back((n.to_ref(), depth, Context::DML, false));
210 }
211 }
212 if let Some(rel) = s.relation.as_ref() {
213 iter.push_back((rel.to_ref(), depth, Context::DML, false));
214 }
215 }
216 NodeRef::CallStmt(s) => {
217 if let Some(n) = s.funccall.as_ref() {
218 iter.push_back((n.to_ref(), depth, Context::Call, false));
219 }
220 }
221 NodeRef::AlterTableStmt(s) => {
225 if let Some(rel) = s.relation.as_ref() {
226 iter.push_back((rel.to_ref(), depth, Context::DDL, false));
227 }
228 }
229 NodeRef::CreateStmt(s) => {
230 if let Some(rel) = s.relation.as_ref() {
231 iter.push_back((rel.to_ref(), depth, Context::DDL, false));
232 }
233 }
234 NodeRef::CreateTableAsStmt(s) => {
235 if let Some(n) = &s.query {
236 if let Some(n) = n.node.as_ref() {
237 iter.push_back((n.to_ref(), depth, Context::DDL, false));
238 }
239 }
240 if let Some(n) = &s.into {
241 if let Some(rel) = n.rel.as_ref() {
242 iter.push_back((rel.to_ref(), depth, Context::DDL, false));
243 }
244 }
245 }
246 NodeRef::TruncateStmt(s) => {
247 s.relations.iter().for_each(|n| {
248 if let Some(n) = n.node.as_ref() {
249 iter.push_back((n.to_ref(), depth, Context::DDL, false));
250 }
251 });
252 }
253 NodeRef::ViewStmt(s) => {
254 if let Some(n) = &s.query {
255 if let Some(n) = n.node.as_ref() {
256 iter.push_back((n.to_ref(), depth, Context::DDL, false));
257 }
258 }
259 if let Some(rel) = s.view.as_ref() {
260 iter.push_back((rel.to_ref(), depth, Context::DDL, false));
261 }
262 }
263 NodeRef::IndexStmt(s) => {
264 if let Some(rel) = s.relation.as_ref() {
265 iter.push_back((rel.to_ref(), depth, Context::DDL, false));
266 }
267 s.index_params.iter().for_each(|n| {
268 if let Some(NodeEnum::IndexElem(n)) = n.node.as_ref() {
269 iter.push_back((n.to_ref(), depth, Context::DDL, false));
270
271 if let Some(n) = n.expr.as_ref().and_then(|n| n.node.as_ref()) {
272 iter.push_back((n.to_ref(), depth, Context::DDL, false));
273 }
274 }
275 });
276 if let Some(n) = s.where_clause.as_ref() {
277 if let Some(n) = n.node.as_ref() {
278 iter.push_back((n.to_ref(), depth, Context::DDL, true));
279 }
280 }
281 }
282 NodeRef::CreateTrigStmt(s) => {
283 if let Some(rel) = s.relation.as_ref() {
284 iter.push_back((rel.to_ref(), depth, Context::DDL, false));
285 }
286 }
287 NodeRef::RuleStmt(s) => {
288 if let Some(rel) = s.relation.as_ref() {
289 iter.push_back((rel.to_ref(), depth, Context::DDL, false));
290 }
291 }
292 NodeRef::VacuumStmt(s) => {
293 for node in &s.rels {
294 if let Some(NodeEnum::VacuumRelation(r)) = &node.node {
295 if let Some(rel) = r.relation.as_ref() {
296 iter.push_back((rel.to_ref(), depth, Context::DDL, false));
297 }
298 }
299 }
300 }
301 NodeRef::RefreshMatViewStmt(s) => {
302 if let Some(rel) = s.relation.as_ref() {
303 iter.push_back((rel.to_ref(), depth, Context::DDL, false));
304 }
305 }
306 NodeRef::GrantStmt(s) => {
307 if let Ok(protobuf::ObjectType::ObjectTable) = protobuf::ObjectType::try_from(s.objtype) {
308 s.objects.iter().for_each(|n| {
309 if let Some(n) = n.node.as_ref() {
310 iter.push_back((n.to_ref(), depth, Context::DDL, false));
311 }
312 });
313 }
314 }
315 NodeRef::LockStmt(s) => {
316 s.relations.iter().for_each(|n| {
317 if let Some(n) = n.node.as_ref() {
318 iter.push_back((n.to_ref(), depth, Context::DDL, false));
319 }
320 });
321 }
322 NodeRef::ExplainStmt(s) => {
323 if let Some(n) = &s.query {
324 if let Some(n) = n.node.as_ref() {
325 iter.push_back((n.to_ref(), depth, context, false));
326 }
327 }
328 }
329 NodeRef::AExpr(e) => {
333 if let Some(n) = &e.lexpr {
334 if let Some(n) = n.node.as_ref() {
335 iter.push_back((n.to_ref(), depth, context, has_filter_columns));
336 }
337 }
338 if let Some(n) = &e.rexpr {
339 if let Some(n) = n.node.as_ref() {
340 iter.push_back((n.to_ref(), depth, context, has_filter_columns));
341 }
342 }
343 }
344 NodeRef::BoolExpr(e) => {
345 e.args.iter().for_each(|n| {
346 if let Some(n) = n.node.as_ref() {
347 iter.push_back((n.to_ref(), depth, context, has_filter_columns));
348 }
349 });
350 }
351 NodeRef::BooleanTest(e) => {
352 if let Some(n) = &e.arg {
353 if let Some(n) = n.node.as_ref() {
354 iter.push_back((n.to_ref(), depth, context, has_filter_columns));
355 }
356 }
357 }
358 NodeRef::CoalesceExpr(e) => {
359 e.args.iter().for_each(|n| {
360 if let Some(n) = n.node.as_ref() {
361 iter.push_back((n.to_ref(), depth, context, has_filter_columns));
362 }
363 });
364 }
365 NodeRef::MinMaxExpr(e) => {
366 e.args.iter().for_each(|n| {
367 if let Some(n) = n.node.as_ref() {
368 iter.push_back((n.to_ref(), depth, context, has_filter_columns));
369 }
370 });
371 }
372 NodeRef::NullTest(e) => {
373 if let Some(n) = &e.arg {
374 if let Some(n) = n.node.as_ref() {
375 iter.push_back((n.to_ref(), depth, context, has_filter_columns));
376 }
377 }
378 }
379 NodeRef::ResTarget(t) => {
380 if let Some(n) = &t.val {
381 if let Some(n) = n.node.as_ref() {
382 iter.push_back((n.to_ref(), depth, context, has_filter_columns));
383 }
384 }
385 }
386 NodeRef::SubLink(l) => {
387 if let Some(n) = &l.subselect {
388 if let Some(n) = n.node.as_ref() {
389 iter.push_back((n.to_ref(), depth, context, has_filter_columns));
390 }
391 }
392 }
393 NodeRef::FuncCall(c) => {
394 c.args.iter().for_each(|n| {
395 if let Some(n) = n.node.as_ref() {
396 iter.push_back((n.to_ref(), depth, context, has_filter_columns));
397 }
398 });
399 }
400 NodeRef::CaseExpr(c) => {
401 c.args.iter().for_each(|n| {
402 if let Some(n) = n.node.as_ref() {
403 iter.push_back((n.to_ref(), depth, context, has_filter_columns));
404 }
405 });
406 if let Some(n) = &c.defresult {
407 if let Some(n) = n.node.as_ref() {
408 iter.push_back((n.to_ref(), depth, context, has_filter_columns));
409 }
410 }
411 }
412 NodeRef::CaseWhen(w) => {
413 if let Some(n) = &w.expr {
414 if let Some(n) = n.node.as_ref() {
415 iter.push_back((n.to_ref(), depth, context, has_filter_columns));
416 }
417 }
418 if let Some(n) = &w.result {
419 if let Some(n) = n.node.as_ref() {
420 iter.push_back((n.to_ref(), depth, context, has_filter_columns));
421 }
422 }
423 }
424 NodeRef::SortBy(n) => {
425 if let Some(n) = &n.node {
426 if let Some(n) = n.node.as_ref() {
427 iter.push_back((n.to_ref(), depth, context, has_filter_columns));
428 }
429 }
430 }
431 NodeRef::TypeCast(n) => {
432 if let Some(n) = &n.arg {
433 if let Some(n) = n.node.as_ref() {
434 iter.push_back((n.to_ref(), depth, context, has_filter_columns));
435 }
436 }
437 }
438 NodeRef::List(l) => {
442 l.items.iter().for_each(|n| {
443 if let Some(n) = n.node.as_ref() {
444 iter.push_back((n.to_ref(), depth, context, has_filter_columns));
445 }
446 });
447 }
448 NodeRef::JoinExpr(e) => {
449 [&e.larg, &e.rarg, &e.quals].iter().for_each(|n| {
450 if let Some(n) = n {
451 if let Some(n) = n.node.as_ref() {
452 iter.push_back((n.to_ref(), depth, context, has_filter_columns));
453 }
454 }
455 });
456 }
457 NodeRef::RowExpr(e) => {
458 e.args.iter().for_each(|n| {
459 if let Some(n) = n.node.as_ref() {
460 iter.push_back((n.to_ref(), depth, context, has_filter_columns));
461 }
462 });
463 }
464 NodeRef::RangeSubselect(s) => {
465 if let Some(n) = &s.subquery {
466 if let Some(n) = n.node.as_ref() {
467 iter.push_back((n.to_ref(), depth, context, has_filter_columns));
468 }
469 }
470 }
471 NodeRef::RangeFunction(f) => {
472 f.functions.iter().for_each(|n| {
473 if let Some(n) = n.node.as_ref() {
474 iter.push_back((n.to_ref(), depth, context, has_filter_columns));
475 }
476 });
477 }
478 _ => (),
479 }
480 nodes.push((node, depth, context, has_filter_columns));
481 }
482 nodes
483 }
484
485 pub unsafe fn nodes_mut(&mut self) -> Vec<(NodeMut, i32, Context)> {
492 let mut iter = VecDeque::new();
493 iter.push_front((self.to_mut(), 0, Context::None));
494 let mut nodes = Vec::new();
495 while let Some((node, depth, context)) = iter.pop_front() {
496 let depth = depth + 1;
497 match node {
498 NodeMut::SelectStmt(s) => {
502 let s = s.as_mut().unwrap();
503 s.target_list.iter_mut().for_each(|n| {
504 if let Some(n) = n.node.as_mut() {
505 iter.push_back((n.to_mut(), depth, Context::Select));
506 }
507 });
508 if let Some(n) = s.where_clause.as_mut() {
509 if let Some(n) = n.node.as_mut() {
510 iter.push_back((n.to_mut(), depth, Context::Select));
511 }
512 }
513 s.sort_clause.iter_mut().for_each(|n| {
514 if let Some(n) = n.node.as_mut() {
515 iter.push_back((n.to_mut(), depth, Context::Select));
516 }
517 });
518 s.group_clause.iter_mut().for_each(|n| {
519 if let Some(n) = n.node.as_mut() {
520 iter.push_back((n.to_mut(), depth, Context::Select));
521 }
522 });
523 if let Some(n) = s.having_clause.as_mut() {
524 if let Some(n) = n.node.as_mut() {
525 iter.push_back((n.to_mut(), depth, Context::Select));
526 }
527 }
528 if let Some(clause) = s.with_clause.as_mut() {
529 clause.ctes.iter_mut().for_each(|n| {
530 if let Some(n) = n.node.as_mut() {
531 iter.push_back((n.to_mut(), depth, Context::Select));
532 }
533 });
534 }
535 match protobuf::SetOperation::try_from(s.op) {
536 Ok(protobuf::SetOperation::SetopNone) => {
537 s.from_clause.iter_mut().for_each(|n| {
538 if let Some(n) = n.node.as_mut() {
539 iter.push_back((n.to_mut(), depth, Context::Select));
540 }
541 });
542 }
543 Ok(protobuf::SetOperation::SetopUnion) => {
544 if let Some(left) = s.larg.as_mut() {
545 iter.push_back((left.to_mut(), depth, Context::Select));
546 }
547 if let Some(right) = s.rarg.as_mut() {
548 iter.push_back((right.to_mut(), depth, Context::Select));
549 }
550 }
551 Ok(protobuf::SetOperation::SetopExcept) => {
552 if let Some(left) = s.larg.as_mut() {
553 iter.push_back((left.to_mut(), depth, Context::Select));
554 }
555 if let Some(right) = s.rarg.as_mut() {
556 iter.push_back((right.to_mut(), depth, Context::Select));
557 }
558 }
559 Ok(protobuf::SetOperation::SetopIntersect) => {
560 if let Some(left) = s.larg.as_mut() {
561 iter.push_back((left.to_mut(), depth, Context::Select));
562 }
563 if let Some(right) = s.rarg.as_mut() {
564 iter.push_back((right.to_mut(), depth, Context::Select));
565 }
566 }
567 Ok(protobuf::SetOperation::Undefined) | Err(_) => (),
568 }
569 }
570 NodeMut::InsertStmt(s) => {
571 let s = s.as_mut().unwrap();
572 if let Some(n) = s.select_stmt.as_mut() {
573 if let Some(n) = n.node.as_mut() {
574 iter.push_back((n.to_mut(), depth, Context::DML));
575 }
576 }
577 if let Some(rel) = s.relation.as_mut() {
578 iter.push_back((rel.to_mut(), depth, Context::DML));
579 }
580 if let Some(clause) = s.with_clause.as_mut() {
581 clause.ctes.iter_mut().for_each(|n| {
582 if let Some(n) = n.node.as_mut() {
583 iter.push_back((n.to_mut(), depth, Context::DML));
584 }
585 });
586 }
587 if let Some(n) = s.on_conflict_clause.as_mut() {
588 iter.push_back((n.to_mut(), depth, Context::DML));
589 }
590 }
591 NodeMut::UpdateStmt(s) => {
592 let s = s.as_mut().unwrap();
593 s.target_list.iter_mut().for_each(|n| {
594 if let Some(n) = n.node.as_mut() {
595 iter.push_back((n.to_mut(), depth, Context::DML));
596 }
597 });
598 s.where_clause.iter_mut().for_each(|n| {
599 if let Some(n) = n.node.as_mut() {
600 iter.push_back((n.to_mut(), depth, Context::DML));
601 }
602 });
603 s.from_clause.iter_mut().for_each(|n| {
604 if let Some(n) = n.node.as_mut() {
605 iter.push_back((n.to_mut(), depth, Context::Select));
606 }
607 });
608 if let Some(rel) = s.relation.as_mut() {
609 iter.push_back((rel.to_mut(), depth, Context::DML));
610 }
611 if let Some(clause) = s.with_clause.as_mut() {
612 clause.ctes.iter_mut().for_each(|n| {
613 if let Some(n) = n.node.as_mut() {
614 iter.push_back((n.to_mut(), depth, Context::DML));
615 }
616 });
617 }
618 }
619 NodeMut::DeleteStmt(s) => {
620 let s = s.as_mut().unwrap();
621 if let Some(n) = s.where_clause.as_mut() {
622 if let Some(n) = n.node.as_mut() {
623 iter.push_back((n.to_mut(), depth, Context::DML));
624 }
625 }
626 if let Some(rel) = s.relation.as_mut() {
627 iter.push_back((rel.to_mut(), depth, Context::DML));
628 }
629 if let Some(clause) = s.with_clause.as_mut() {
630 clause.ctes.iter_mut().for_each(|n| {
631 if let Some(n) = n.node.as_mut() {
632 iter.push_back((n.to_mut(), depth, Context::DML));
633 }
634 });
635 }
636 s.using_clause.iter_mut().for_each(|n| {
637 if let Some(n) = n.node.as_mut() {
638 iter.push_back((n.to_mut(), depth, Context::Select));
639 }
640 });
641 }
642 NodeMut::CommonTableExpr(s) => {
643 let s = s.as_mut().unwrap();
644 if let Some(n) = s.ctequery.as_mut() {
645 if let Some(n) = n.node.as_mut() {
646 iter.push_back((n.to_mut(), depth, context));
647 }
648 }
649 }
650 NodeMut::CopyStmt(s) => {
651 let s = s.as_mut().unwrap();
652 if let Some(n) = s.query.as_mut() {
653 if let Some(n) = n.node.as_mut() {
654 iter.push_back((n.to_mut(), depth, Context::DML));
655 }
656 }
657 if let Some(rel) = s.relation.as_mut() {
658 iter.push_back((rel.to_mut(), depth, Context::DML));
659 }
660 }
661 NodeMut::CallStmt(s) => {
662 let s = s.as_mut().unwrap();
663 if let Some(n) = s.funccall.as_mut() {
664 iter.push_back((n.to_mut(), depth, Context::Call));
665 }
666 }
667 NodeMut::AlterTableStmt(s) => {
671 let s = s.as_mut().unwrap();
672 if let Some(rel) = s.relation.as_mut() {
673 iter.push_back((rel.to_mut(), depth, Context::DDL));
674 }
675 }
676 NodeMut::CreateStmt(s) => {
677 let s = s.as_mut().unwrap();
678 if let Some(rel) = s.relation.as_mut() {
679 iter.push_back((rel.to_mut(), depth, Context::DDL));
680 }
681 }
682 NodeMut::CreateTableAsStmt(s) => {
683 let s = s.as_mut().unwrap();
684 if let Some(n) = s.query.as_mut() {
685 if let Some(n) = n.node.as_mut() {
686 iter.push_back((n.to_mut(), depth, Context::DDL));
687 }
688 }
689 if let Some(n) = s.into.as_mut() {
690 if let Some(rel) = n.rel.as_mut() {
691 iter.push_back((rel.to_mut(), depth, Context::DDL));
692 }
693 }
694 }
695 NodeMut::TruncateStmt(s) => {
696 let s = s.as_mut().unwrap();
697 s.relations.iter_mut().for_each(|n| {
698 if let Some(n) = n.node.as_mut() {
699 iter.push_back((n.to_mut(), depth, Context::DDL));
700 }
701 });
702 }
703 NodeMut::ViewStmt(s) => {
704 let s = s.as_mut().unwrap();
705 if let Some(n) = s.query.as_mut() {
706 if let Some(n) = n.node.as_mut() {
707 iter.push_back((n.to_mut(), depth, Context::DDL));
708 }
709 }
710 if let Some(rel) = s.view.as_mut() {
711 iter.push_back((rel.to_mut(), depth, Context::DDL));
712 }
713 }
714 NodeMut::IndexStmt(s) => {
715 let s = s.as_mut().unwrap();
716 if let Some(rel) = s.relation.as_mut() {
717 iter.push_back((rel.to_mut(), depth, Context::DDL));
718 }
719 s.index_params.iter_mut().for_each(|n| {
720 if let Some(NodeEnum::IndexElem(n)) = n.node.as_mut() {
721 if let Some(n) = n.expr.as_mut().and_then(|n| n.node.as_mut()) {
722 iter.push_back((n.to_mut(), depth, Context::DDL));
723 }
724 }
725 });
726 }
727 NodeMut::CreateTrigStmt(s) => {
728 let s = s.as_mut().unwrap();
729 if let Some(rel) = s.relation.as_mut() {
730 iter.push_back((rel.to_mut(), depth, Context::DDL));
731 }
732 }
733 NodeMut::RuleStmt(s) => {
734 let s = s.as_mut().unwrap();
735 if let Some(rel) = s.relation.as_mut() {
736 iter.push_back((rel.to_mut(), depth, Context::DDL));
737 }
738 }
739 NodeMut::VacuumStmt(s) => {
740 let s = s.as_mut().unwrap();
741 for node in s.rels.iter_mut() {
742 if let Some(NodeEnum::VacuumRelation(r)) = node.node.as_mut() {
743 if let Some(rel) = r.relation.as_mut() {
744 iter.push_back((rel.to_mut(), depth, Context::DDL));
745 }
746 }
747 }
748 }
749 NodeMut::RefreshMatViewStmt(s) => {
750 let s = s.as_mut().unwrap();
751 if let Some(rel) = s.relation.as_mut() {
752 iter.push_back((rel.to_mut(), depth, Context::DDL));
753 }
754 }
755 NodeMut::GrantStmt(s) => {
756 let s = s.as_mut().unwrap();
757 if let Ok(protobuf::ObjectType::ObjectTable) = protobuf::ObjectType::try_from(s.objtype) {
758 s.objects.iter_mut().for_each(|n| {
759 if let Some(n) = n.node.as_mut() {
760 iter.push_back((n.to_mut(), depth, Context::DDL));
761 }
762 });
763 }
764 }
765 NodeMut::LockStmt(s) => {
766 let s = s.as_mut().unwrap();
767 s.relations.iter_mut().for_each(|n| {
768 if let Some(n) = n.node.as_mut() {
769 iter.push_back((n.to_mut(), depth, Context::DDL));
770 }
771 });
772 }
773 NodeMut::ExplainStmt(s) => {
774 let s = s.as_mut().unwrap();
775 if let Some(n) = s.query.as_mut() {
776 if let Some(n) = n.node.as_mut() {
777 iter.push_back((n.to_mut(), depth, context));
778 }
779 }
780 }
781 NodeMut::AExpr(e) => {
785 let e = e.as_mut().unwrap();
786 if let Some(n) = e.lexpr.as_mut() {
787 if let Some(n) = n.node.as_mut() {
788 iter.push_back((n.to_mut(), depth, context));
789 }
790 }
791 if let Some(n) = e.rexpr.as_mut() {
792 if let Some(n) = n.node.as_mut() {
793 iter.push_back((n.to_mut(), depth, context));
794 }
795 }
796 }
797 NodeMut::BoolExpr(e) => {
798 let e = e.as_mut().unwrap();
799 e.args.iter_mut().for_each(|n| {
800 if let Some(n) = n.node.as_mut() {
801 iter.push_back((n.to_mut(), depth, context));
802 }
803 });
804 }
805 NodeMut::CoalesceExpr(e) => {
806 let e = e.as_mut().unwrap();
807 e.args.iter_mut().for_each(|n| {
808 if let Some(n) = n.node.as_mut() {
809 iter.push_back((n.to_mut(), depth, context));
810 }
811 });
812 }
813 NodeMut::MinMaxExpr(e) => {
814 let e = e.as_mut().unwrap();
815 e.args.iter_mut().for_each(|n| {
816 if let Some(n) = n.node.as_mut() {
817 iter.push_back((n.to_mut(), depth, context));
818 }
819 });
820 }
821 NodeMut::NullTest(e) => {
822 let e = e.as_mut().unwrap();
823 if let Some(n) = e.arg.as_mut() {
824 if let Some(n) = n.node.as_mut() {
825 iter.push_back((n.to_mut(), depth, context));
826 }
827 }
828 }
829 NodeMut::ResTarget(t) => {
830 let t = t.as_mut().unwrap();
831 if let Some(n) = t.val.as_mut() {
832 if let Some(n) = n.node.as_mut() {
833 iter.push_back((n.to_mut(), depth, context));
834 }
835 }
836 }
837 NodeMut::SubLink(l) => {
838 let l = l.as_mut().unwrap();
839 if let Some(n) = l.subselect.as_mut() {
840 if let Some(n) = n.node.as_mut() {
841 iter.push_back((n.to_mut(), depth, context));
842 }
843 }
844 }
845 NodeMut::FuncCall(c) => {
846 let c = c.as_mut().unwrap();
847 c.args.iter_mut().for_each(|n| {
848 if let Some(n) = n.node.as_mut() {
849 iter.push_back((n.to_mut(), depth, context));
850 }
851 });
852 }
853 NodeMut::CaseExpr(c) => {
854 let c = c.as_mut().unwrap();
855 c.args.iter_mut().for_each(|n| {
856 if let Some(n) = n.node.as_mut() {
857 iter.push_back((n.to_mut(), depth, context));
858 }
859 });
860 if let Some(n) = c.defresult.as_mut() {
861 if let Some(n) = n.node.as_mut() {
862 iter.push_back((n.to_mut(), depth, context));
863 }
864 }
865 }
866 NodeMut::CaseWhen(w) => {
867 let w = w.as_mut().unwrap();
868 if let Some(n) = w.expr.as_mut() {
869 if let Some(n) = n.node.as_mut() {
870 iter.push_back((n.to_mut(), depth, context));
871 }
872 }
873 if let Some(n) = w.result.as_mut() {
874 if let Some(n) = n.node.as_mut() {
875 iter.push_back((n.to_mut(), depth, context));
876 }
877 }
878 }
879 NodeMut::SortBy(n) => {
880 let n = n.as_mut().unwrap();
881 if let Some(n) = n.node.as_mut() {
882 if let Some(n) = n.node.as_mut() {
883 iter.push_back((n.to_mut(), depth, context));
884 }
885 }
886 }
887 NodeMut::TypeCast(t) => {
888 let t = t.as_mut().unwrap();
889 if let Some(n) = t.arg.as_mut() {
890 if let Some(n) = n.node.as_mut() {
891 iter.push_back((n.to_mut(), depth, context));
892 }
893 }
894 }
895 NodeMut::List(l) => {
899 let l = l.as_mut().unwrap();
900 l.items.iter_mut().for_each(|n| {
901 if let Some(n) = n.node.as_mut() {
902 iter.push_back((n.to_mut(), depth, context));
903 }
904 });
905 }
906 NodeMut::JoinExpr(e) => {
907 let e = e.as_mut().unwrap();
908 if let Some(n) = e.larg.as_mut() {
909 if let Some(n) = n.node.as_mut() {
910 iter.push_back((n.to_mut(), depth, context));
911 }
912 }
913 if let Some(n) = e.rarg.as_mut() {
914 if let Some(n) = n.node.as_mut() {
915 iter.push_back((n.to_mut(), depth, context));
916 }
917 }
918 if let Some(n) = e.quals.as_mut() {
919 if let Some(n) = n.node.as_mut() {
920 iter.push_back((n.to_mut(), depth, context));
921 }
922 }
923 }
924 NodeMut::RowExpr(e) => {
925 let e = e.as_mut().unwrap();
926 e.args.iter_mut().for_each(|n| {
927 if let Some(n) = n.node.as_mut() {
928 iter.push_back((n.to_mut(), depth, context));
929 }
930 });
931 }
932 NodeMut::RangeSubselect(s) => {
933 let s = s.as_mut().unwrap();
934 if let Some(n) = s.subquery.as_mut() {
935 if let Some(n) = n.node.as_mut() {
936 iter.push_back((n.to_mut(), depth, context));
937 }
938 }
939 }
940 NodeMut::RangeFunction(f) => {
941 let f = f.as_mut().unwrap();
942 f.functions.iter_mut().for_each(|n| {
943 if let Some(n) = n.node.as_mut() {
944 iter.push_back((n.to_mut(), depth, context));
945 }
946 });
947 }
948 _ => (),
949 }
950 nodes.push((node, depth, context));
951 }
952 nodes
953 }
954
955 pub fn to_ref(&self) -> NodeRef<'_> {
956 match self {
957 NodeEnum::Alias(n) => NodeRef::Alias(n),
958 NodeEnum::RangeVar(n) => NodeRef::RangeVar(n),
959 NodeEnum::TableFunc(n) => NodeRef::TableFunc(n),
960 NodeEnum::Var(n) => NodeRef::Var(n),
961 NodeEnum::Param(n) => NodeRef::Param(n),
962 NodeEnum::Aggref(n) => NodeRef::Aggref(n),
963 NodeEnum::GroupingFunc(n) => NodeRef::GroupingFunc(n),
964 NodeEnum::WindowFunc(n) => NodeRef::WindowFunc(n),
965 NodeEnum::SubscriptingRef(n) => NodeRef::SubscriptingRef(n),
966 NodeEnum::FuncExpr(n) => NodeRef::FuncExpr(n),
967 NodeEnum::NamedArgExpr(n) => NodeRef::NamedArgExpr(n),
968 NodeEnum::OpExpr(n) => NodeRef::OpExpr(n),
969 NodeEnum::DistinctExpr(n) => NodeRef::DistinctExpr(n),
970 NodeEnum::NullIfExpr(n) => NodeRef::NullIfExpr(n),
971 NodeEnum::ScalarArrayOpExpr(n) => NodeRef::ScalarArrayOpExpr(n),
972 NodeEnum::BoolExpr(n) => NodeRef::BoolExpr(n),
973 NodeEnum::SubLink(n) => NodeRef::SubLink(n),
974 NodeEnum::SubPlan(n) => NodeRef::SubPlan(n),
975 NodeEnum::AlternativeSubPlan(n) => NodeRef::AlternativeSubPlan(n),
976 NodeEnum::FieldSelect(n) => NodeRef::FieldSelect(n),
977 NodeEnum::FieldStore(n) => NodeRef::FieldStore(n),
978 NodeEnum::RelabelType(n) => NodeRef::RelabelType(n),
979 NodeEnum::CoerceViaIo(n) => NodeRef::CoerceViaIo(n),
980 NodeEnum::ArrayCoerceExpr(n) => NodeRef::ArrayCoerceExpr(n),
981 NodeEnum::ConvertRowtypeExpr(n) => NodeRef::ConvertRowtypeExpr(n),
982 NodeEnum::CollateExpr(n) => NodeRef::CollateExpr(n),
983 NodeEnum::CaseExpr(n) => NodeRef::CaseExpr(n),
984 NodeEnum::CaseWhen(n) => NodeRef::CaseWhen(n),
985 NodeEnum::CaseTestExpr(n) => NodeRef::CaseTestExpr(n),
986 NodeEnum::ArrayExpr(n) => NodeRef::ArrayExpr(n),
987 NodeEnum::RowExpr(n) => NodeRef::RowExpr(n),
988 NodeEnum::RowCompareExpr(n) => NodeRef::RowCompareExpr(n),
989 NodeEnum::CoalesceExpr(n) => NodeRef::CoalesceExpr(n),
990 NodeEnum::MinMaxExpr(n) => NodeRef::MinMaxExpr(n),
991 NodeEnum::SqlvalueFunction(n) => NodeRef::SqlvalueFunction(n),
992 NodeEnum::XmlExpr(n) => NodeRef::XmlExpr(n),
993 NodeEnum::NullTest(n) => NodeRef::NullTest(n),
994 NodeEnum::BooleanTest(n) => NodeRef::BooleanTest(n),
995 NodeEnum::CoerceToDomain(n) => NodeRef::CoerceToDomain(n),
996 NodeEnum::CoerceToDomainValue(n) => NodeRef::CoerceToDomainValue(n),
997 NodeEnum::SetToDefault(n) => NodeRef::SetToDefault(n),
998 NodeEnum::CurrentOfExpr(n) => NodeRef::CurrentOfExpr(n),
999 NodeEnum::NextValueExpr(n) => NodeRef::NextValueExpr(n),
1000 NodeEnum::InferenceElem(n) => NodeRef::InferenceElem(n),
1001 NodeEnum::TargetEntry(n) => NodeRef::TargetEntry(n),
1002 NodeEnum::RangeTblRef(n) => NodeRef::RangeTblRef(n),
1003 NodeEnum::JoinExpr(n) => NodeRef::JoinExpr(n),
1004 NodeEnum::FromExpr(n) => NodeRef::FromExpr(n),
1005 NodeEnum::OnConflictExpr(n) => NodeRef::OnConflictExpr(n),
1006 NodeEnum::IntoClause(n) => NodeRef::IntoClause(n),
1007 NodeEnum::RawStmt(n) => NodeRef::RawStmt(n),
1008 NodeEnum::Query(n) => NodeRef::Query(n),
1009 NodeEnum::InsertStmt(n) => NodeRef::InsertStmt(n),
1010 NodeEnum::DeleteStmt(n) => NodeRef::DeleteStmt(n),
1011 NodeEnum::UpdateStmt(n) => NodeRef::UpdateStmt(n),
1012 NodeEnum::SelectStmt(n) => NodeRef::SelectStmt(n),
1013 NodeEnum::AlterTableStmt(n) => NodeRef::AlterTableStmt(n),
1014 NodeEnum::AlterTableCmd(n) => NodeRef::AlterTableCmd(n),
1015 NodeEnum::AlterDomainStmt(n) => NodeRef::AlterDomainStmt(n),
1016 NodeEnum::SetOperationStmt(n) => NodeRef::SetOperationStmt(n),
1017 NodeEnum::GrantStmt(n) => NodeRef::GrantStmt(n),
1018 NodeEnum::GrantRoleStmt(n) => NodeRef::GrantRoleStmt(n),
1019 NodeEnum::AlterDefaultPrivilegesStmt(n) => NodeRef::AlterDefaultPrivilegesStmt(n),
1020 NodeEnum::ClosePortalStmt(n) => NodeRef::ClosePortalStmt(n),
1021 NodeEnum::ClusterStmt(n) => NodeRef::ClusterStmt(n),
1022 NodeEnum::CopyStmt(n) => NodeRef::CopyStmt(n),
1023 NodeEnum::CreateStmt(n) => NodeRef::CreateStmt(n),
1024 NodeEnum::DefineStmt(n) => NodeRef::DefineStmt(n),
1025 NodeEnum::DropStmt(n) => NodeRef::DropStmt(n),
1026 NodeEnum::TruncateStmt(n) => NodeRef::TruncateStmt(n),
1027 NodeEnum::CommentStmt(n) => NodeRef::CommentStmt(n),
1028 NodeEnum::FetchStmt(n) => NodeRef::FetchStmt(n),
1029 NodeEnum::IndexStmt(n) => NodeRef::IndexStmt(n),
1030 NodeEnum::CreateFunctionStmt(n) => NodeRef::CreateFunctionStmt(n),
1031 NodeEnum::AlterFunctionStmt(n) => NodeRef::AlterFunctionStmt(n),
1032 NodeEnum::DoStmt(n) => NodeRef::DoStmt(n),
1033 NodeEnum::RenameStmt(n) => NodeRef::RenameStmt(n),
1034 NodeEnum::RuleStmt(n) => NodeRef::RuleStmt(n),
1035 NodeEnum::NotifyStmt(n) => NodeRef::NotifyStmt(n),
1036 NodeEnum::ListenStmt(n) => NodeRef::ListenStmt(n),
1037 NodeEnum::UnlistenStmt(n) => NodeRef::UnlistenStmt(n),
1038 NodeEnum::TransactionStmt(n) => NodeRef::TransactionStmt(n),
1039 NodeEnum::ViewStmt(n) => NodeRef::ViewStmt(n),
1040 NodeEnum::LoadStmt(n) => NodeRef::LoadStmt(n),
1041 NodeEnum::CreateDomainStmt(n) => NodeRef::CreateDomainStmt(n),
1042 NodeEnum::CreatedbStmt(n) => NodeRef::CreatedbStmt(n),
1043 NodeEnum::DropdbStmt(n) => NodeRef::DropdbStmt(n),
1044 NodeEnum::VacuumStmt(n) => NodeRef::VacuumStmt(n),
1045 NodeEnum::ExplainStmt(n) => NodeRef::ExplainStmt(n),
1046 NodeEnum::CreateTableAsStmt(n) => NodeRef::CreateTableAsStmt(n),
1047 NodeEnum::CreateSeqStmt(n) => NodeRef::CreateSeqStmt(n),
1048 NodeEnum::AlterSeqStmt(n) => NodeRef::AlterSeqStmt(n),
1049 NodeEnum::VariableSetStmt(n) => NodeRef::VariableSetStmt(n),
1050 NodeEnum::VariableShowStmt(n) => NodeRef::VariableShowStmt(n),
1051 NodeEnum::DiscardStmt(n) => NodeRef::DiscardStmt(n),
1052 NodeEnum::CreateTrigStmt(n) => NodeRef::CreateTrigStmt(n),
1053 NodeEnum::CreatePlangStmt(n) => NodeRef::CreatePlangStmt(n),
1054 NodeEnum::CreateRoleStmt(n) => NodeRef::CreateRoleStmt(n),
1055 NodeEnum::AlterRoleStmt(n) => NodeRef::AlterRoleStmt(n),
1056 NodeEnum::DropRoleStmt(n) => NodeRef::DropRoleStmt(n),
1057 NodeEnum::LockStmt(n) => NodeRef::LockStmt(n),
1058 NodeEnum::ConstraintsSetStmt(n) => NodeRef::ConstraintsSetStmt(n),
1059 NodeEnum::ReindexStmt(n) => NodeRef::ReindexStmt(n),
1060 NodeEnum::CheckPointStmt(n) => NodeRef::CheckPointStmt(n),
1061 NodeEnum::CreateSchemaStmt(n) => NodeRef::CreateSchemaStmt(n),
1062 NodeEnum::AlterDatabaseStmt(n) => NodeRef::AlterDatabaseStmt(n),
1063 NodeEnum::AlterDatabaseSetStmt(n) => NodeRef::AlterDatabaseSetStmt(n),
1064 NodeEnum::AlterRoleSetStmt(n) => NodeRef::AlterRoleSetStmt(n),
1065 NodeEnum::CreateConversionStmt(n) => NodeRef::CreateConversionStmt(n),
1066 NodeEnum::CreateCastStmt(n) => NodeRef::CreateCastStmt(n),
1067 NodeEnum::CreateOpClassStmt(n) => NodeRef::CreateOpClassStmt(n),
1068 NodeEnum::CreateOpFamilyStmt(n) => NodeRef::CreateOpFamilyStmt(n),
1069 NodeEnum::AlterOpFamilyStmt(n) => NodeRef::AlterOpFamilyStmt(n),
1070 NodeEnum::PrepareStmt(n) => NodeRef::PrepareStmt(n),
1071 NodeEnum::ExecuteStmt(n) => NodeRef::ExecuteStmt(n),
1072 NodeEnum::DeallocateStmt(n) => NodeRef::DeallocateStmt(n),
1073 NodeEnum::DeclareCursorStmt(n) => NodeRef::DeclareCursorStmt(n),
1074 NodeEnum::CreateTableSpaceStmt(n) => NodeRef::CreateTableSpaceStmt(n),
1075 NodeEnum::DropTableSpaceStmt(n) => NodeRef::DropTableSpaceStmt(n),
1076 NodeEnum::AlterObjectDependsStmt(n) => NodeRef::AlterObjectDependsStmt(n),
1077 NodeEnum::AlterObjectSchemaStmt(n) => NodeRef::AlterObjectSchemaStmt(n),
1078 NodeEnum::AlterOwnerStmt(n) => NodeRef::AlterOwnerStmt(n),
1079 NodeEnum::AlterOperatorStmt(n) => NodeRef::AlterOperatorStmt(n),
1080 NodeEnum::AlterTypeStmt(n) => NodeRef::AlterTypeStmt(n),
1081 NodeEnum::AtalterConstraint(n) => NodeRef::AtalterConstraint(n),
1082 NodeEnum::DropOwnedStmt(n) => NodeRef::DropOwnedStmt(n),
1083 NodeEnum::ReassignOwnedStmt(n) => NodeRef::ReassignOwnedStmt(n),
1084 NodeEnum::CompositeTypeStmt(n) => NodeRef::CompositeTypeStmt(n),
1085 NodeEnum::CreateEnumStmt(n) => NodeRef::CreateEnumStmt(n),
1086 NodeEnum::CreateRangeStmt(n) => NodeRef::CreateRangeStmt(n),
1087 NodeEnum::AlterEnumStmt(n) => NodeRef::AlterEnumStmt(n),
1088 NodeEnum::AlterTsdictionaryStmt(n) => NodeRef::AlterTsdictionaryStmt(n),
1089 NodeEnum::AlterTsconfigurationStmt(n) => NodeRef::AlterTsconfigurationStmt(n),
1090 NodeEnum::CreateFdwStmt(n) => NodeRef::CreateFdwStmt(n),
1091 NodeEnum::AlterFdwStmt(n) => NodeRef::AlterFdwStmt(n),
1092 NodeEnum::CreateForeignServerStmt(n) => NodeRef::CreateForeignServerStmt(n),
1093 NodeEnum::AlterForeignServerStmt(n) => NodeRef::AlterForeignServerStmt(n),
1094 NodeEnum::CreateUserMappingStmt(n) => NodeRef::CreateUserMappingStmt(n),
1095 NodeEnum::AlterUserMappingStmt(n) => NodeRef::AlterUserMappingStmt(n),
1096 NodeEnum::DropUserMappingStmt(n) => NodeRef::DropUserMappingStmt(n),
1097 NodeEnum::AlterTableSpaceOptionsStmt(n) => NodeRef::AlterTableSpaceOptionsStmt(n),
1098 NodeEnum::AlterTableMoveAllStmt(n) => NodeRef::AlterTableMoveAllStmt(n),
1099 NodeEnum::SecLabelStmt(n) => NodeRef::SecLabelStmt(n),
1100 NodeEnum::CreateForeignTableStmt(n) => NodeRef::CreateForeignTableStmt(n),
1101 NodeEnum::ImportForeignSchemaStmt(n) => NodeRef::ImportForeignSchemaStmt(n),
1102 NodeEnum::CreateExtensionStmt(n) => NodeRef::CreateExtensionStmt(n),
1103 NodeEnum::AlterExtensionStmt(n) => NodeRef::AlterExtensionStmt(n),
1104 NodeEnum::AlterExtensionContentsStmt(n) => NodeRef::AlterExtensionContentsStmt(n),
1105 NodeEnum::CreateEventTrigStmt(n) => NodeRef::CreateEventTrigStmt(n),
1106 NodeEnum::AlterEventTrigStmt(n) => NodeRef::AlterEventTrigStmt(n),
1107 NodeEnum::RefreshMatViewStmt(n) => NodeRef::RefreshMatViewStmt(n),
1108 NodeEnum::ReplicaIdentityStmt(n) => NodeRef::ReplicaIdentityStmt(n),
1109 NodeEnum::AlterSystemStmt(n) => NodeRef::AlterSystemStmt(n),
1110 NodeEnum::CreatePolicyStmt(n) => NodeRef::CreatePolicyStmt(n),
1111 NodeEnum::AlterPolicyStmt(n) => NodeRef::AlterPolicyStmt(n),
1112 NodeEnum::CreateTransformStmt(n) => NodeRef::CreateTransformStmt(n),
1113 NodeEnum::CreateAmStmt(n) => NodeRef::CreateAmStmt(n),
1114 NodeEnum::CreatePublicationStmt(n) => NodeRef::CreatePublicationStmt(n),
1115 NodeEnum::AlterPublicationStmt(n) => NodeRef::AlterPublicationStmt(n),
1116 NodeEnum::CreateSubscriptionStmt(n) => NodeRef::CreateSubscriptionStmt(n),
1117 NodeEnum::AlterSubscriptionStmt(n) => NodeRef::AlterSubscriptionStmt(n),
1118 NodeEnum::DropSubscriptionStmt(n) => NodeRef::DropSubscriptionStmt(n),
1119 NodeEnum::CreateStatsStmt(n) => NodeRef::CreateStatsStmt(n),
1120 NodeEnum::AlterCollationStmt(n) => NodeRef::AlterCollationStmt(n),
1121 NodeEnum::CallStmt(n) => NodeRef::CallStmt(n),
1122 NodeEnum::AlterStatsStmt(n) => NodeRef::AlterStatsStmt(n),
1123 NodeEnum::AExpr(n) => NodeRef::AExpr(n),
1124 NodeEnum::ColumnRef(n) => NodeRef::ColumnRef(n),
1125 NodeEnum::ParamRef(n) => NodeRef::ParamRef(n),
1126 NodeEnum::AConst(n) => NodeRef::AConst(n),
1127 NodeEnum::FuncCall(n) => NodeRef::FuncCall(n),
1128 NodeEnum::AStar(n) => NodeRef::AStar(n),
1129 NodeEnum::AIndices(n) => NodeRef::AIndices(n),
1130 NodeEnum::AIndirection(n) => NodeRef::AIndirection(n),
1131 NodeEnum::AArrayExpr(n) => NodeRef::AArrayExpr(n),
1132 NodeEnum::ResTarget(n) => NodeRef::ResTarget(n),
1133 NodeEnum::MultiAssignRef(n) => NodeRef::MultiAssignRef(n),
1134 NodeEnum::TypeCast(n) => NodeRef::TypeCast(n),
1135 NodeEnum::CollateClause(n) => NodeRef::CollateClause(n),
1136 NodeEnum::SortBy(n) => NodeRef::SortBy(n),
1137 NodeEnum::WindowDef(n) => NodeRef::WindowDef(n),
1138 NodeEnum::RangeSubselect(n) => NodeRef::RangeSubselect(n),
1139 NodeEnum::RangeFunction(n) => NodeRef::RangeFunction(n),
1140 NodeEnum::RangeTableSample(n) => NodeRef::RangeTableSample(n),
1141 NodeEnum::RangeTableFunc(n) => NodeRef::RangeTableFunc(n),
1142 NodeEnum::RangeTableFuncCol(n) => NodeRef::RangeTableFuncCol(n),
1143 NodeEnum::TypeName(n) => NodeRef::TypeName(n),
1144 NodeEnum::ColumnDef(n) => NodeRef::ColumnDef(n),
1145 NodeEnum::IndexElem(n) => NodeRef::IndexElem(n),
1146 NodeEnum::Constraint(n) => NodeRef::Constraint(n),
1147 NodeEnum::DefElem(n) => NodeRef::DefElem(n),
1148 NodeEnum::RangeTblEntry(n) => NodeRef::RangeTblEntry(n),
1149 NodeEnum::RangeTblFunction(n) => NodeRef::RangeTblFunction(n),
1150 NodeEnum::TableSampleClause(n) => NodeRef::TableSampleClause(n),
1151 NodeEnum::WithCheckOption(n) => NodeRef::WithCheckOption(n),
1152 NodeEnum::SortGroupClause(n) => NodeRef::SortGroupClause(n),
1153 NodeEnum::GroupingSet(n) => NodeRef::GroupingSet(n),
1154 NodeEnum::WindowClause(n) => NodeRef::WindowClause(n),
1155 NodeEnum::ObjectWithArgs(n) => NodeRef::ObjectWithArgs(n),
1156 NodeEnum::AccessPriv(n) => NodeRef::AccessPriv(n),
1157 NodeEnum::CreateOpClassItem(n) => NodeRef::CreateOpClassItem(n),
1158 NodeEnum::TableLikeClause(n) => NodeRef::TableLikeClause(n),
1159 NodeEnum::FunctionParameter(n) => NodeRef::FunctionParameter(n),
1160 NodeEnum::LockingClause(n) => NodeRef::LockingClause(n),
1161 NodeEnum::RowMarkClause(n) => NodeRef::RowMarkClause(n),
1162 NodeEnum::XmlSerialize(n) => NodeRef::XmlSerialize(n),
1163 NodeEnum::WithClause(n) => NodeRef::WithClause(n),
1164 NodeEnum::InferClause(n) => NodeRef::InferClause(n),
1165 NodeEnum::OnConflictClause(n) => NodeRef::OnConflictClause(n),
1166 NodeEnum::CommonTableExpr(n) => NodeRef::CommonTableExpr(n),
1167 NodeEnum::RoleSpec(n) => NodeRef::RoleSpec(n),
1168 NodeEnum::TriggerTransition(n) => NodeRef::TriggerTransition(n),
1169 NodeEnum::PartitionElem(n) => NodeRef::PartitionElem(n),
1170 NodeEnum::PartitionSpec(n) => NodeRef::PartitionSpec(n),
1171 NodeEnum::PartitionBoundSpec(n) => NodeRef::PartitionBoundSpec(n),
1172 NodeEnum::PartitionRangeDatum(n) => NodeRef::PartitionRangeDatum(n),
1173 NodeEnum::PartitionCmd(n) => NodeRef::PartitionCmd(n),
1174 NodeEnum::VacuumRelation(n) => NodeRef::VacuumRelation(n),
1175 NodeEnum::InlineCodeBlock(n) => NodeRef::InlineCodeBlock(n),
1176 NodeEnum::CallContext(n) => NodeRef::CallContext(n),
1177 NodeEnum::Integer(n) => NodeRef::Integer(n),
1178 NodeEnum::Float(n) => NodeRef::Float(n),
1179 NodeEnum::Boolean(n) => NodeRef::Boolean(n),
1180 NodeEnum::String(n) => NodeRef::String(n),
1181 NodeEnum::BitString(n) => NodeRef::BitString(n),
1182 NodeEnum::List(n) => NodeRef::List(n),
1183 NodeEnum::IntList(n) => NodeRef::IntList(n),
1184 NodeEnum::OidList(n) => NodeRef::OidList(n),
1185 NodeEnum::MergeStmt(n) => NodeRef::MergeStmt(n),
1186 NodeEnum::MergeAction(n) => NodeRef::MergeAction(n),
1187 NodeEnum::AlterDatabaseRefreshCollStmt(n) => NodeRef::AlterDatabaseRefreshCollStmt(n),
1188 NodeEnum::ReturnStmt(n) => NodeRef::ReturnStmt(n),
1189 NodeEnum::ReturningClause(n) => NodeRef::ReturningClause(n),
1190 NodeEnum::ReturningExpr(n) => NodeRef::ReturningExpr(n),
1191 NodeEnum::ReturningOption(n) => NodeRef::ReturningOption(n),
1192 NodeEnum::PlassignStmt(n) => NodeRef::PlassignStmt(n),
1193 NodeEnum::StatsElem(n) => NodeRef::StatsElem(n),
1194 NodeEnum::CtesearchClause(n) => NodeRef::CtesearchClause(n),
1195 NodeEnum::CtecycleClause(n) => NodeRef::CtecycleClause(n),
1196 NodeEnum::MergeWhenClause(n) => NodeRef::MergeWhenClause(n),
1197 NodeEnum::PublicationObjSpec(n) => NodeRef::PublicationObjSpec(n),
1198 NodeEnum::PublicationTable(n) => NodeRef::PublicationTable(n),
1199 NodeEnum::JsonFormat(n) => NodeRef::JsonFormat(n),
1200 NodeEnum::JsonReturning(n) => NodeRef::JsonReturning(n),
1201 NodeEnum::JsonValueExpr(n) => NodeRef::JsonValueExpr(n),
1202 NodeEnum::JsonConstructorExpr(n) => NodeRef::JsonConstructorExpr(n),
1203 NodeEnum::JsonIsPredicate(n) => NodeRef::JsonIsPredicate(n),
1204 NodeEnum::JsonOutput(n) => NodeRef::JsonOutput(n),
1205 NodeEnum::JsonKeyValue(n) => NodeRef::JsonKeyValue(n),
1206 NodeEnum::JsonObjectConstructor(n) => NodeRef::JsonObjectConstructor(n),
1207 NodeEnum::JsonArrayConstructor(n) => NodeRef::JsonArrayConstructor(n),
1208 NodeEnum::JsonArrayQueryConstructor(n) => NodeRef::JsonArrayQueryConstructor(n),
1209 NodeEnum::JsonAggConstructor(n) => NodeRef::JsonAggConstructor(n),
1210 NodeEnum::JsonObjectAgg(n) => NodeRef::JsonObjectAgg(n),
1211 NodeEnum::JsonArrayAgg(n) => NodeRef::JsonArrayAgg(n),
1212 NodeEnum::RtepermissionInfo(n) => NodeRef::RtepermissionInfo(n),
1213 NodeEnum::WindowFuncRunCondition(n) => NodeRef::WindowFuncRunCondition(n),
1214 NodeEnum::MergeSupportFunc(n) => NodeRef::MergeSupportFunc(n),
1215 NodeEnum::JsonBehavior(n) => NodeRef::JsonBehavior(n),
1216 NodeEnum::JsonExpr(n) => NodeRef::JsonExpr(n),
1217 NodeEnum::JsonTablePath(n) => NodeRef::JsonTablePath(n),
1218 NodeEnum::JsonTablePathScan(n) => NodeRef::JsonTablePathScan(n),
1219 NodeEnum::JsonTableSiblingJoin(n) => NodeRef::JsonTableSiblingJoin(n),
1220 NodeEnum::JsonArgument(n) => NodeRef::JsonArgument(n),
1221 NodeEnum::JsonFuncExpr(n) => NodeRef::JsonFuncExpr(n),
1222 NodeEnum::JsonTablePathSpec(n) => NodeRef::JsonTablePathSpec(n),
1223 NodeEnum::JsonTable(n) => NodeRef::JsonTable(n),
1224 NodeEnum::JsonTableColumn(n) => NodeRef::JsonTableColumn(n),
1225 NodeEnum::JsonParseExpr(n) => NodeRef::JsonParseExpr(n),
1226 NodeEnum::JsonScalarExpr(n) => NodeRef::JsonScalarExpr(n),
1227 NodeEnum::JsonSerializeExpr(n) => NodeRef::JsonSerializeExpr(n),
1228 }
1229 }
1230
1231 pub fn to_mut(&mut self) -> NodeMut {
1232 match self {
1233 NodeEnum::Alias(n) => NodeMut::Alias(n as *mut _),
1234 NodeEnum::RangeVar(n) => NodeMut::RangeVar(n as *mut _),
1235 NodeEnum::TableFunc(n) => NodeMut::TableFunc(&mut **n as *mut _),
1236 NodeEnum::Var(n) => NodeMut::Var(&mut **n as *mut _),
1237 NodeEnum::Param(n) => NodeMut::Param(&mut **n as *mut _),
1238 NodeEnum::Aggref(n) => NodeMut::Aggref(&mut **n as *mut _),
1239 NodeEnum::GroupingFunc(n) => NodeMut::GroupingFunc(&mut **n as *mut _),
1240 NodeEnum::WindowFunc(n) => NodeMut::WindowFunc(&mut **n as *mut _),
1241 NodeEnum::SubscriptingRef(n) => NodeMut::SubscriptingRef(&mut **n as *mut _),
1242 NodeEnum::FuncExpr(n) => NodeMut::FuncExpr(&mut **n as *mut _),
1243 NodeEnum::NamedArgExpr(n) => NodeMut::NamedArgExpr(&mut **n as *mut _),
1244 NodeEnum::OpExpr(n) => NodeMut::OpExpr(&mut **n as *mut _),
1245 NodeEnum::DistinctExpr(n) => NodeMut::DistinctExpr(&mut **n as *mut _),
1246 NodeEnum::NullIfExpr(n) => NodeMut::NullIfExpr(&mut **n as *mut _),
1247 NodeEnum::ScalarArrayOpExpr(n) => NodeMut::ScalarArrayOpExpr(&mut **n as *mut _),
1248 NodeEnum::BoolExpr(n) => NodeMut::BoolExpr(&mut **n as *mut _),
1249 NodeEnum::SubLink(n) => NodeMut::SubLink(&mut **n as *mut _),
1250 NodeEnum::SubPlan(n) => NodeMut::SubPlan(&mut **n as *mut _),
1251 NodeEnum::AlternativeSubPlan(n) => NodeMut::AlternativeSubPlan(&mut **n as *mut _),
1252 NodeEnum::FieldSelect(n) => NodeMut::FieldSelect(&mut **n as *mut _),
1253 NodeEnum::FieldStore(n) => NodeMut::FieldStore(&mut **n as *mut _),
1254 NodeEnum::RelabelType(n) => NodeMut::RelabelType(&mut **n as *mut _),
1255 NodeEnum::CoerceViaIo(n) => NodeMut::CoerceViaIo(&mut **n as *mut _),
1256 NodeEnum::ArrayCoerceExpr(n) => NodeMut::ArrayCoerceExpr(&mut **n as *mut _),
1257 NodeEnum::ConvertRowtypeExpr(n) => NodeMut::ConvertRowtypeExpr(&mut **n as *mut _),
1258 NodeEnum::CollateExpr(n) => NodeMut::CollateExpr(&mut **n as *mut _),
1259 NodeEnum::CaseExpr(n) => NodeMut::CaseExpr(&mut **n as *mut _),
1260 NodeEnum::CaseWhen(n) => NodeMut::CaseWhen(&mut **n as *mut _),
1261 NodeEnum::CaseTestExpr(n) => NodeMut::CaseTestExpr(&mut **n as *mut _),
1262 NodeEnum::ArrayExpr(n) => NodeMut::ArrayExpr(&mut **n as *mut _),
1263 NodeEnum::RowExpr(n) => NodeMut::RowExpr(&mut **n as *mut _),
1264 NodeEnum::RowCompareExpr(n) => NodeMut::RowCompareExpr(&mut **n as *mut _),
1265 NodeEnum::CoalesceExpr(n) => NodeMut::CoalesceExpr(&mut **n as *mut _),
1266 NodeEnum::MinMaxExpr(n) => NodeMut::MinMaxExpr(&mut **n as *mut _),
1267 NodeEnum::SqlvalueFunction(n) => NodeMut::SqlvalueFunction(&mut **n as *mut _),
1268 NodeEnum::XmlExpr(n) => NodeMut::XmlExpr(&mut **n as *mut _),
1269 NodeEnum::NullTest(n) => NodeMut::NullTest(&mut **n as *mut _),
1270 NodeEnum::BooleanTest(n) => NodeMut::BooleanTest(&mut **n as *mut _),
1271 NodeEnum::CoerceToDomain(n) => NodeMut::CoerceToDomain(&mut **n as *mut _),
1272 NodeEnum::CoerceToDomainValue(n) => NodeMut::CoerceToDomainValue(&mut **n as *mut _),
1273 NodeEnum::SetToDefault(n) => NodeMut::SetToDefault(&mut **n as *mut _),
1274 NodeEnum::CurrentOfExpr(n) => NodeMut::CurrentOfExpr(&mut **n as *mut _),
1275 NodeEnum::NextValueExpr(n) => NodeMut::NextValueExpr(&mut **n as *mut _),
1276 NodeEnum::InferenceElem(n) => NodeMut::InferenceElem(&mut **n as *mut _),
1277 NodeEnum::TargetEntry(n) => NodeMut::TargetEntry(&mut **n as *mut _),
1278 NodeEnum::RangeTblRef(n) => NodeMut::RangeTblRef(n as *mut _),
1279 NodeEnum::JoinExpr(n) => NodeMut::JoinExpr(&mut **n as *mut _),
1280 NodeEnum::FromExpr(n) => NodeMut::FromExpr(&mut **n as *mut _),
1281 NodeEnum::OnConflictExpr(n) => NodeMut::OnConflictExpr(&mut **n as *mut _),
1282 NodeEnum::IntoClause(n) => NodeMut::IntoClause(&mut **n as *mut _),
1283 NodeEnum::RawStmt(n) => NodeMut::RawStmt(&mut **n as *mut _),
1284 NodeEnum::Query(n) => NodeMut::Query(&mut **n as *mut _),
1285 NodeEnum::InsertStmt(n) => NodeMut::InsertStmt(&mut **n as *mut _),
1286 NodeEnum::DeleteStmt(n) => NodeMut::DeleteStmt(&mut **n as *mut _),
1287 NodeEnum::UpdateStmt(n) => NodeMut::UpdateStmt(&mut **n as *mut _),
1288 NodeEnum::SelectStmt(n) => NodeMut::SelectStmt(&mut **n as *mut _),
1289 NodeEnum::AlterTableStmt(n) => NodeMut::AlterTableStmt(n as *mut _),
1290 NodeEnum::AlterTableCmd(n) => NodeMut::AlterTableCmd(&mut **n as *mut _),
1291 NodeEnum::AlterDomainStmt(n) => NodeMut::AlterDomainStmt(&mut **n as *mut _),
1292 NodeEnum::SetOperationStmt(n) => NodeMut::SetOperationStmt(&mut **n as *mut _),
1293 NodeEnum::GrantStmt(n) => NodeMut::GrantStmt(n as *mut _),
1294 NodeEnum::GrantRoleStmt(n) => NodeMut::GrantRoleStmt(n as *mut _),
1295 NodeEnum::AlterDefaultPrivilegesStmt(n) => NodeMut::AlterDefaultPrivilegesStmt(n as *mut _),
1296 NodeEnum::ClosePortalStmt(n) => NodeMut::ClosePortalStmt(n as *mut _),
1297 NodeEnum::ClusterStmt(n) => NodeMut::ClusterStmt(n as *mut _),
1298 NodeEnum::CopyStmt(n) => NodeMut::CopyStmt(&mut **n as *mut _),
1299 NodeEnum::CreateStmt(n) => NodeMut::CreateStmt(n as *mut _),
1300 NodeEnum::DefineStmt(n) => NodeMut::DefineStmt(n as *mut _),
1301 NodeEnum::DropStmt(n) => NodeMut::DropStmt(n as *mut _),
1302 NodeEnum::TruncateStmt(n) => NodeMut::TruncateStmt(n as *mut _),
1303 NodeEnum::CommentStmt(n) => NodeMut::CommentStmt(&mut **n as *mut _),
1304 NodeEnum::FetchStmt(n) => NodeMut::FetchStmt(n as *mut _),
1305 NodeEnum::IndexStmt(n) => NodeMut::IndexStmt(&mut **n as *mut _),
1306 NodeEnum::CreateFunctionStmt(n) => NodeMut::CreateFunctionStmt(&mut **n as *mut _),
1307 NodeEnum::AlterFunctionStmt(n) => NodeMut::AlterFunctionStmt(n as *mut _),
1308 NodeEnum::DoStmt(n) => NodeMut::DoStmt(n as *mut _),
1309 NodeEnum::RenameStmt(n) => NodeMut::RenameStmt(&mut **n as *mut _),
1310 NodeEnum::RuleStmt(n) => NodeMut::RuleStmt(&mut **n as *mut _),
1311 NodeEnum::NotifyStmt(n) => NodeMut::NotifyStmt(n as *mut _),
1312 NodeEnum::ListenStmt(n) => NodeMut::ListenStmt(n as *mut _),
1313 NodeEnum::UnlistenStmt(n) => NodeMut::UnlistenStmt(n as *mut _),
1314 NodeEnum::TransactionStmt(n) => NodeMut::TransactionStmt(n as *mut _),
1315 NodeEnum::ViewStmt(n) => NodeMut::ViewStmt(&mut **n as *mut _),
1316 NodeEnum::LoadStmt(n) => NodeMut::LoadStmt(n as *mut _),
1317 NodeEnum::CreateDomainStmt(n) => NodeMut::CreateDomainStmt(&mut **n as *mut _),
1318 NodeEnum::CreatedbStmt(n) => NodeMut::CreatedbStmt(n as *mut _),
1319 NodeEnum::DropdbStmt(n) => NodeMut::DropdbStmt(n as *mut _),
1320 NodeEnum::VacuumStmt(n) => NodeMut::VacuumStmt(n as *mut _),
1321 NodeEnum::ExplainStmt(n) => NodeMut::ExplainStmt(&mut **n as *mut _),
1322 NodeEnum::CreateTableAsStmt(n) => NodeMut::CreateTableAsStmt(&mut **n as *mut _),
1323 NodeEnum::CreateSeqStmt(n) => NodeMut::CreateSeqStmt(n as *mut _),
1324 NodeEnum::AlterSeqStmt(n) => NodeMut::AlterSeqStmt(n as *mut _),
1325 NodeEnum::VariableSetStmt(n) => NodeMut::VariableSetStmt(n as *mut _),
1326 NodeEnum::VariableShowStmt(n) => NodeMut::VariableShowStmt(n as *mut _),
1327 NodeEnum::DiscardStmt(n) => NodeMut::DiscardStmt(n as *mut _),
1328 NodeEnum::CreateTrigStmt(n) => NodeMut::CreateTrigStmt(&mut **n as *mut _),
1329 NodeEnum::CreatePlangStmt(n) => NodeMut::CreatePlangStmt(n as *mut _),
1330 NodeEnum::CreateRoleStmt(n) => NodeMut::CreateRoleStmt(n as *mut _),
1331 NodeEnum::AlterRoleStmt(n) => NodeMut::AlterRoleStmt(n as *mut _),
1332 NodeEnum::DropRoleStmt(n) => NodeMut::DropRoleStmt(n as *mut _),
1333 NodeEnum::LockStmt(n) => NodeMut::LockStmt(n as *mut _),
1334 NodeEnum::ConstraintsSetStmt(n) => NodeMut::ConstraintsSetStmt(n as *mut _),
1335 NodeEnum::ReindexStmt(n) => NodeMut::ReindexStmt(n as *mut _),
1336 NodeEnum::CheckPointStmt(n) => NodeMut::CheckPointStmt(n as *mut _),
1337 NodeEnum::CreateSchemaStmt(n) => NodeMut::CreateSchemaStmt(n as *mut _),
1338 NodeEnum::AlterDatabaseStmt(n) => NodeMut::AlterDatabaseStmt(n as *mut _),
1339 NodeEnum::AlterDatabaseSetStmt(n) => NodeMut::AlterDatabaseSetStmt(n as *mut _),
1340 NodeEnum::AlterRoleSetStmt(n) => NodeMut::AlterRoleSetStmt(n as *mut _),
1341 NodeEnum::CreateConversionStmt(n) => NodeMut::CreateConversionStmt(n as *mut _),
1342 NodeEnum::CreateCastStmt(n) => NodeMut::CreateCastStmt(n as *mut _),
1343 NodeEnum::CreateOpClassStmt(n) => NodeMut::CreateOpClassStmt(n as *mut _),
1344 NodeEnum::CreateOpFamilyStmt(n) => NodeMut::CreateOpFamilyStmt(n as *mut _),
1345 NodeEnum::AlterOpFamilyStmt(n) => NodeMut::AlterOpFamilyStmt(n as *mut _),
1346 NodeEnum::PrepareStmt(n) => NodeMut::PrepareStmt(&mut **n as *mut _),
1347 NodeEnum::ExecuteStmt(n) => NodeMut::ExecuteStmt(n as *mut _),
1348 NodeEnum::DeallocateStmt(n) => NodeMut::DeallocateStmt(n as *mut _),
1349 NodeEnum::DeclareCursorStmt(n) => NodeMut::DeclareCursorStmt(&mut **n as *mut _),
1350 NodeEnum::CreateTableSpaceStmt(n) => NodeMut::CreateTableSpaceStmt(n as *mut _),
1351 NodeEnum::DropTableSpaceStmt(n) => NodeMut::DropTableSpaceStmt(n as *mut _),
1352 NodeEnum::AlterObjectDependsStmt(n) => NodeMut::AlterObjectDependsStmt(&mut **n as *mut _),
1353 NodeEnum::AlterObjectSchemaStmt(n) => NodeMut::AlterObjectSchemaStmt(&mut **n as *mut _),
1354 NodeEnum::AlterOwnerStmt(n) => NodeMut::AlterOwnerStmt(&mut **n as *mut _),
1355 NodeEnum::AlterOperatorStmt(n) => NodeMut::AlterOperatorStmt(n as *mut _),
1356 NodeEnum::AlterTypeStmt(n) => NodeMut::AlterTypeStmt(n as *mut _),
1357 NodeEnum::AtalterConstraint(n) => NodeMut::AtalterConstraint(n as *mut _),
1358 NodeEnum::DropOwnedStmt(n) => NodeMut::DropOwnedStmt(n as *mut _),
1359 NodeEnum::ReassignOwnedStmt(n) => NodeMut::ReassignOwnedStmt(n as *mut _),
1360 NodeEnum::CompositeTypeStmt(n) => NodeMut::CompositeTypeStmt(n as *mut _),
1361 NodeEnum::CreateEnumStmt(n) => NodeMut::CreateEnumStmt(n as *mut _),
1362 NodeEnum::CreateRangeStmt(n) => NodeMut::CreateRangeStmt(n as *mut _),
1363 NodeEnum::AlterEnumStmt(n) => NodeMut::AlterEnumStmt(n as *mut _),
1364 NodeEnum::AlterTsdictionaryStmt(n) => NodeMut::AlterTsdictionaryStmt(n as *mut _),
1365 NodeEnum::AlterTsconfigurationStmt(n) => NodeMut::AlterTsconfigurationStmt(n as *mut _),
1366 NodeEnum::CreateFdwStmt(n) => NodeMut::CreateFdwStmt(n as *mut _),
1367 NodeEnum::AlterFdwStmt(n) => NodeMut::AlterFdwStmt(n as *mut _),
1368 NodeEnum::CreateForeignServerStmt(n) => NodeMut::CreateForeignServerStmt(n as *mut _),
1369 NodeEnum::AlterForeignServerStmt(n) => NodeMut::AlterForeignServerStmt(n as *mut _),
1370 NodeEnum::CreateUserMappingStmt(n) => NodeMut::CreateUserMappingStmt(n as *mut _),
1371 NodeEnum::AlterUserMappingStmt(n) => NodeMut::AlterUserMappingStmt(n as *mut _),
1372 NodeEnum::DropUserMappingStmt(n) => NodeMut::DropUserMappingStmt(n as *mut _),
1373 NodeEnum::AlterTableSpaceOptionsStmt(n) => NodeMut::AlterTableSpaceOptionsStmt(n as *mut _),
1374 NodeEnum::AlterTableMoveAllStmt(n) => NodeMut::AlterTableMoveAllStmt(n as *mut _),
1375 NodeEnum::SecLabelStmt(n) => NodeMut::SecLabelStmt(&mut **n as *mut _),
1376 NodeEnum::CreateForeignTableStmt(n) => NodeMut::CreateForeignTableStmt(n as *mut _),
1377 NodeEnum::ImportForeignSchemaStmt(n) => NodeMut::ImportForeignSchemaStmt(n as *mut _),
1378 NodeEnum::CreateExtensionStmt(n) => NodeMut::CreateExtensionStmt(n as *mut _),
1379 NodeEnum::AlterExtensionStmt(n) => NodeMut::AlterExtensionStmt(n as *mut _),
1380 NodeEnum::AlterExtensionContentsStmt(n) => NodeMut::AlterExtensionContentsStmt(&mut **n as *mut _),
1381 NodeEnum::CreateEventTrigStmt(n) => NodeMut::CreateEventTrigStmt(n as *mut _),
1382 NodeEnum::AlterEventTrigStmt(n) => NodeMut::AlterEventTrigStmt(n as *mut _),
1383 NodeEnum::RefreshMatViewStmt(n) => NodeMut::RefreshMatViewStmt(n as *mut _),
1384 NodeEnum::ReplicaIdentityStmt(n) => NodeMut::ReplicaIdentityStmt(n as *mut _),
1385 NodeEnum::AlterSystemStmt(n) => NodeMut::AlterSystemStmt(n as *mut _),
1386 NodeEnum::CreatePolicyStmt(n) => NodeMut::CreatePolicyStmt(&mut **n as *mut _),
1387 NodeEnum::AlterPolicyStmt(n) => NodeMut::AlterPolicyStmt(&mut **n as *mut _),
1388 NodeEnum::CreateTransformStmt(n) => NodeMut::CreateTransformStmt(n as *mut _),
1389 NodeEnum::CreateAmStmt(n) => NodeMut::CreateAmStmt(n as *mut _),
1390 NodeEnum::CreatePublicationStmt(n) => NodeMut::CreatePublicationStmt(n as *mut _),
1391 NodeEnum::AlterPublicationStmt(n) => NodeMut::AlterPublicationStmt(n as *mut _),
1392 NodeEnum::CreateSubscriptionStmt(n) => NodeMut::CreateSubscriptionStmt(n as *mut _),
1393 NodeEnum::AlterSubscriptionStmt(n) => NodeMut::AlterSubscriptionStmt(n as *mut _),
1394 NodeEnum::DropSubscriptionStmt(n) => NodeMut::DropSubscriptionStmt(n as *mut _),
1395 NodeEnum::CreateStatsStmt(n) => NodeMut::CreateStatsStmt(n as *mut _),
1396 NodeEnum::AlterCollationStmt(n) => NodeMut::AlterCollationStmt(n as *mut _),
1397 NodeEnum::CallStmt(n) => NodeMut::CallStmt(&mut **n as *mut _),
1398 NodeEnum::AlterStatsStmt(n) => NodeMut::AlterStatsStmt(&mut **n as *mut _),
1399 NodeEnum::AExpr(n) => NodeMut::AExpr(&mut **n as *mut _),
1400 NodeEnum::ColumnRef(n) => NodeMut::ColumnRef(n as *mut _),
1401 NodeEnum::ParamRef(n) => NodeMut::ParamRef(n as *mut _),
1402 NodeEnum::AConst(n) => NodeMut::AConst(n as *mut _),
1403 NodeEnum::FuncCall(n) => NodeMut::FuncCall(&mut **n as *mut _),
1404 NodeEnum::AStar(n) => NodeMut::AStar(n as *mut _),
1405 NodeEnum::AIndices(n) => NodeMut::AIndices(&mut **n as *mut _),
1406 NodeEnum::AIndirection(n) => NodeMut::AIndirection(&mut **n as *mut _),
1407 NodeEnum::AArrayExpr(n) => NodeMut::AArrayExpr(n as *mut _),
1408 NodeEnum::ResTarget(n) => NodeMut::ResTarget(&mut **n as *mut _),
1409 NodeEnum::MultiAssignRef(n) => NodeMut::MultiAssignRef(&mut **n as *mut _),
1410 NodeEnum::TypeCast(n) => NodeMut::TypeCast(&mut **n as *mut _),
1411 NodeEnum::CollateClause(n) => NodeMut::CollateClause(&mut **n as *mut _),
1412 NodeEnum::SortBy(n) => NodeMut::SortBy(&mut **n as *mut _),
1413 NodeEnum::WindowDef(n) => NodeMut::WindowDef(&mut **n as *mut _),
1414 NodeEnum::RangeSubselect(n) => NodeMut::RangeSubselect(&mut **n as *mut _),
1415 NodeEnum::RangeFunction(n) => NodeMut::RangeFunction(n as *mut _),
1416 NodeEnum::RangeTableSample(n) => NodeMut::RangeTableSample(&mut **n as *mut _),
1417 NodeEnum::RangeTableFunc(n) => NodeMut::RangeTableFunc(&mut **n as *mut _),
1418 NodeEnum::RangeTableFuncCol(n) => NodeMut::RangeTableFuncCol(&mut **n as *mut _),
1419 NodeEnum::TypeName(n) => NodeMut::TypeName(n as *mut _),
1420 NodeEnum::ColumnDef(n) => NodeMut::ColumnDef(&mut **n as *mut _),
1421 NodeEnum::IndexElem(n) => NodeMut::IndexElem(&mut **n as *mut _),
1422 NodeEnum::Constraint(n) => NodeMut::Constraint(&mut **n as *mut _),
1423 NodeEnum::DefElem(n) => NodeMut::DefElem(&mut **n as *mut _),
1424 NodeEnum::RangeTblEntry(n) => NodeMut::RangeTblEntry(&mut **n as *mut _),
1425 NodeEnum::RangeTblFunction(n) => NodeMut::RangeTblFunction(&mut **n as *mut _),
1426 NodeEnum::TableSampleClause(n) => NodeMut::TableSampleClause(&mut **n as *mut _),
1427 NodeEnum::WithCheckOption(n) => NodeMut::WithCheckOption(&mut **n as *mut _),
1428 NodeEnum::SortGroupClause(n) => NodeMut::SortGroupClause(n as *mut _),
1429 NodeEnum::GroupingSet(n) => NodeMut::GroupingSet(n as *mut _),
1430 NodeEnum::WindowClause(n) => NodeMut::WindowClause(&mut **n as *mut _),
1431 NodeEnum::ObjectWithArgs(n) => NodeMut::ObjectWithArgs(n as *mut _),
1432 NodeEnum::AccessPriv(n) => NodeMut::AccessPriv(n as *mut _),
1433 NodeEnum::CreateOpClassItem(n) => NodeMut::CreateOpClassItem(n as *mut _),
1434 NodeEnum::TableLikeClause(n) => NodeMut::TableLikeClause(n as *mut _),
1435 NodeEnum::FunctionParameter(n) => NodeMut::FunctionParameter(&mut **n as *mut _),
1436 NodeEnum::LockingClause(n) => NodeMut::LockingClause(n as *mut _),
1437 NodeEnum::RowMarkClause(n) => NodeMut::RowMarkClause(n as *mut _),
1438 NodeEnum::XmlSerialize(n) => NodeMut::XmlSerialize(&mut **n as *mut _),
1439 NodeEnum::WithClause(n) => NodeMut::WithClause(n as *mut _),
1440 NodeEnum::InferClause(n) => NodeMut::InferClause(&mut **n as *mut _),
1441 NodeEnum::OnConflictClause(n) => NodeMut::OnConflictClause(&mut **n as *mut _),
1442 NodeEnum::CommonTableExpr(n) => NodeMut::CommonTableExpr(&mut **n as *mut _),
1443 NodeEnum::RoleSpec(n) => NodeMut::RoleSpec(n as *mut _),
1444 NodeEnum::TriggerTransition(n) => NodeMut::TriggerTransition(n as *mut _),
1445 NodeEnum::PartitionElem(n) => NodeMut::PartitionElem(&mut **n as *mut _),
1446 NodeEnum::PartitionSpec(n) => NodeMut::PartitionSpec(n as *mut _),
1447 NodeEnum::PartitionBoundSpec(n) => NodeMut::PartitionBoundSpec(n as *mut _),
1448 NodeEnum::PartitionRangeDatum(n) => NodeMut::PartitionRangeDatum(&mut **n as *mut _),
1449 NodeEnum::PartitionCmd(n) => NodeMut::PartitionCmd(n as *mut _),
1450 NodeEnum::VacuumRelation(n) => NodeMut::VacuumRelation(n as *mut _),
1451 NodeEnum::InlineCodeBlock(n) => NodeMut::InlineCodeBlock(n as *mut _),
1452 NodeEnum::CallContext(n) => NodeMut::CallContext(n as *mut _),
1453 NodeEnum::Integer(n) => NodeMut::Integer(n as *mut _),
1454 NodeEnum::Float(n) => NodeMut::Float(n as *mut _),
1455 NodeEnum::Boolean(n) => NodeMut::Boolean(n as *mut _),
1456 NodeEnum::String(n) => NodeMut::String(n as *mut _),
1457 NodeEnum::BitString(n) => NodeMut::BitString(n as *mut _),
1458 NodeEnum::List(n) => NodeMut::List(n as *mut _),
1459 NodeEnum::IntList(n) => NodeMut::IntList(n as *mut _),
1460 NodeEnum::OidList(n) => NodeMut::OidList(n as *mut _),
1461 NodeEnum::MergeStmt(n) => NodeMut::MergeStmt(&mut **n as *mut _),
1462 NodeEnum::MergeAction(n) => NodeMut::MergeAction(&mut **n as *mut _),
1463 NodeEnum::AlterDatabaseRefreshCollStmt(n) => NodeMut::AlterDatabaseRefreshCollStmt(n as *mut _),
1464 NodeEnum::ReturnStmt(n) => NodeMut::ReturnStmt(&mut **n as *mut _),
1465 NodeEnum::ReturningClause(n) => NodeMut::ReturningClause(&mut *n as *mut _),
1466 NodeEnum::ReturningExpr(n) => NodeMut::ReturningExpr(&mut **n as *mut _),
1467 NodeEnum::ReturningOption(n) => NodeMut::ReturningOption(&mut *n as *mut _),
1468 NodeEnum::PlassignStmt(n) => NodeMut::PlassignStmt(&mut **n as *mut _),
1469 NodeEnum::StatsElem(n) => NodeMut::StatsElem(&mut **n as *mut _),
1470 NodeEnum::CtesearchClause(n) => NodeMut::CtesearchClause(n as *mut _),
1471 NodeEnum::CtecycleClause(n) => NodeMut::CtecycleClause(&mut **n as *mut _),
1472 NodeEnum::MergeWhenClause(n) => NodeMut::MergeWhenClause(&mut **n as *mut _),
1473 NodeEnum::PublicationObjSpec(n) => NodeMut::PublicationObjSpec(&mut **n as *mut _),
1474 NodeEnum::PublicationTable(n) => NodeMut::PublicationTable(&mut **n as *mut _),
1475 NodeEnum::JsonFormat(n) => NodeMut::JsonFormat(&mut *n as *mut _),
1476 NodeEnum::JsonReturning(n) => NodeMut::JsonReturning(&mut *n as *mut _),
1477 NodeEnum::JsonValueExpr(n) => NodeMut::JsonValueExpr(&mut **n as *mut _),
1478 NodeEnum::JsonConstructorExpr(n) => NodeMut::JsonConstructorExpr(&mut **n as *mut _),
1479 NodeEnum::JsonIsPredicate(n) => NodeMut::JsonIsPredicate(&mut **n as *mut _),
1480 NodeEnum::JsonOutput(n) => NodeMut::JsonOutput(&mut *n as *mut _),
1481 NodeEnum::JsonKeyValue(n) => NodeMut::JsonKeyValue(&mut **n as *mut _),
1482 NodeEnum::JsonObjectConstructor(n) => NodeMut::JsonObjectConstructor(&mut *n as *mut _),
1483 NodeEnum::JsonArrayConstructor(n) => NodeMut::JsonArrayConstructor(&mut *n as *mut _),
1484 NodeEnum::JsonArrayQueryConstructor(n) => NodeMut::JsonArrayQueryConstructor(&mut **n as *mut _),
1485 NodeEnum::JsonAggConstructor(n) => NodeMut::JsonAggConstructor(&mut **n as *mut _),
1486 NodeEnum::JsonObjectAgg(n) => NodeMut::JsonObjectAgg(&mut **n as *mut _),
1487 NodeEnum::JsonArrayAgg(n) => NodeMut::JsonArrayAgg(&mut **n as *mut _),
1488 NodeEnum::RtepermissionInfo(n) => NodeMut::RtepermissionInfo(&mut *n as *mut _),
1489 NodeEnum::WindowFuncRunCondition(n) => NodeMut::WindowFuncRunCondition(&mut **n as *mut _),
1490 NodeEnum::MergeSupportFunc(n) => NodeMut::MergeSupportFunc(&mut **n as *mut _),
1491 NodeEnum::JsonBehavior(n) => NodeMut::JsonBehavior(&mut **n as *mut _),
1492 NodeEnum::JsonExpr(n) => NodeMut::JsonExpr(&mut **n as *mut _),
1493 NodeEnum::JsonTablePath(n) => NodeMut::JsonTablePath(&mut *n as *mut _),
1494 NodeEnum::JsonTablePathScan(n) => NodeMut::JsonTablePathScan(&mut **n as *mut _),
1495 NodeEnum::JsonTableSiblingJoin(n) => NodeMut::JsonTableSiblingJoin(&mut **n as *mut _),
1496 NodeEnum::JsonArgument(n) => NodeMut::JsonArgument(&mut **n as *mut _),
1497 NodeEnum::JsonFuncExpr(n) => NodeMut::JsonFuncExpr(&mut **n as *mut _),
1498 NodeEnum::JsonTablePathSpec(n) => NodeMut::JsonTablePathSpec(&mut **n as *mut _),
1499 NodeEnum::JsonTable(n) => NodeMut::JsonTable(&mut **n as *mut _),
1500 NodeEnum::JsonTableColumn(n) => NodeMut::JsonTableColumn(&mut **n as *mut _),
1501 NodeEnum::JsonParseExpr(n) => NodeMut::JsonParseExpr(&mut **n as *mut _),
1502 NodeEnum::JsonScalarExpr(n) => NodeMut::JsonScalarExpr(&mut **n as *mut _),
1503 NodeEnum::JsonSerializeExpr(n) => NodeMut::JsonSerializeExpr(&mut **n as *mut _),
1504 }
1505 }
1506}