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