Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * copyfuncs.funcs.c
4 : * Generated node infrastructure code
5 : *
6 : * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
7 : * Portions Copyright (c) 1994, Regents of the University of California
8 : *
9 : * NOTES
10 : * ******************************
11 : * *** DO NOT EDIT THIS FILE! ***
12 : * ******************************
13 : *
14 : * It has been GENERATED by src/backend/nodes/gen_node_support.pl
15 : *
16 : *-------------------------------------------------------------------------
17 : */
18 : #include "access/amapi.h"
19 : #include "access/sdir.h"
20 : #include "access/tableam.h"
21 : #include "access/tsmapi.h"
22 : #include "commands/event_trigger.h"
23 : #include "commands/trigger.h"
24 : #include "executor/tuptable.h"
25 : #include "foreign/fdwapi.h"
26 : #include "nodes/bitmapset.h"
27 : #include "nodes/execnodes.h"
28 : #include "nodes/extensible.h"
29 : #include "nodes/lockoptions.h"
30 : #include "nodes/miscnodes.h"
31 : #include "nodes/nodes.h"
32 : #include "nodes/parsenodes.h"
33 : #include "nodes/pathnodes.h"
34 : #include "nodes/plannodes.h"
35 : #include "nodes/primnodes.h"
36 : #include "nodes/replnodes.h"
37 : #include "nodes/supportnodes.h"
38 : #include "nodes/value.h"
39 : #include "utils/rel.h"
40 :
41 : static Alias *
42 2999364 : _copyAlias(const Alias *from)
43 : {
44 2999364 : Alias *newnode = makeNode(Alias);
45 :
46 2999364 : COPY_STRING_FIELD(aliasname);
47 2999364 : COPY_NODE_FIELD(colnames);
48 :
49 2999364 : return newnode;
50 : }
51 :
52 : static RangeVar *
53 855992 : _copyRangeVar(const RangeVar *from)
54 : {
55 855992 : RangeVar *newnode = makeNode(RangeVar);
56 :
57 855992 : COPY_STRING_FIELD(catalogname);
58 855992 : COPY_STRING_FIELD(schemaname);
59 855992 : COPY_STRING_FIELD(relname);
60 855992 : COPY_SCALAR_FIELD(inh);
61 855992 : COPY_SCALAR_FIELD(relpersistence);
62 855992 : COPY_NODE_FIELD(alias);
63 855992 : COPY_LOCATION_FIELD(location);
64 :
65 855992 : return newnode;
66 : }
67 :
68 : static TableFunc *
69 1360 : _copyTableFunc(const TableFunc *from)
70 : {
71 1360 : TableFunc *newnode = makeNode(TableFunc);
72 :
73 1360 : COPY_SCALAR_FIELD(functype);
74 1360 : COPY_NODE_FIELD(ns_uris);
75 1360 : COPY_NODE_FIELD(ns_names);
76 1360 : COPY_NODE_FIELD(docexpr);
77 1360 : COPY_NODE_FIELD(rowexpr);
78 1360 : COPY_NODE_FIELD(colnames);
79 1360 : COPY_NODE_FIELD(coltypes);
80 1360 : COPY_NODE_FIELD(coltypmods);
81 1360 : COPY_NODE_FIELD(colcollations);
82 1360 : COPY_NODE_FIELD(colexprs);
83 1360 : COPY_NODE_FIELD(coldefexprs);
84 1360 : COPY_NODE_FIELD(colvalexprs);
85 1360 : COPY_NODE_FIELD(passingvalexprs);
86 1360 : COPY_BITMAPSET_FIELD(notnulls);
87 1360 : COPY_NODE_FIELD(plan);
88 1360 : COPY_SCALAR_FIELD(ordinalitycol);
89 1360 : COPY_LOCATION_FIELD(location);
90 :
91 1360 : return newnode;
92 : }
93 :
94 : static IntoClause *
95 4044 : _copyIntoClause(const IntoClause *from)
96 : {
97 4044 : IntoClause *newnode = makeNode(IntoClause);
98 :
99 4044 : COPY_NODE_FIELD(rel);
100 4044 : COPY_NODE_FIELD(colNames);
101 4044 : COPY_STRING_FIELD(accessMethod);
102 4044 : COPY_NODE_FIELD(options);
103 4044 : COPY_SCALAR_FIELD(onCommit);
104 4044 : COPY_STRING_FIELD(tableSpaceName);
105 4044 : COPY_NODE_FIELD(viewQuery);
106 4044 : COPY_SCALAR_FIELD(skipData);
107 :
108 4044 : return newnode;
109 : }
110 :
111 : static Var *
112 15365592 : _copyVar(const Var *from)
113 : {
114 15365592 : Var *newnode = makeNode(Var);
115 :
116 15365592 : COPY_SCALAR_FIELD(varno);
117 15365592 : COPY_SCALAR_FIELD(varattno);
118 15365592 : COPY_SCALAR_FIELD(vartype);
119 15365592 : COPY_SCALAR_FIELD(vartypmod);
120 15365592 : COPY_SCALAR_FIELD(varcollid);
121 15365592 : COPY_BITMAPSET_FIELD(varnullingrels);
122 15365592 : COPY_SCALAR_FIELD(varlevelsup);
123 15365592 : COPY_SCALAR_FIELD(varnosyn);
124 15365592 : COPY_SCALAR_FIELD(varattnosyn);
125 15365592 : COPY_LOCATION_FIELD(location);
126 :
127 15365592 : return newnode;
128 : }
129 :
130 : static Param *
131 961390 : _copyParam(const Param *from)
132 : {
133 961390 : Param *newnode = makeNode(Param);
134 :
135 961390 : COPY_SCALAR_FIELD(paramkind);
136 961390 : COPY_SCALAR_FIELD(paramid);
137 961390 : COPY_SCALAR_FIELD(paramtype);
138 961390 : COPY_SCALAR_FIELD(paramtypmod);
139 961390 : COPY_SCALAR_FIELD(paramcollid);
140 961390 : COPY_LOCATION_FIELD(location);
141 :
142 961390 : return newnode;
143 : }
144 :
145 : static Aggref *
146 181332 : _copyAggref(const Aggref *from)
147 : {
148 181332 : Aggref *newnode = makeNode(Aggref);
149 :
150 181332 : COPY_SCALAR_FIELD(aggfnoid);
151 181332 : COPY_SCALAR_FIELD(aggtype);
152 181332 : COPY_SCALAR_FIELD(aggcollid);
153 181332 : COPY_SCALAR_FIELD(inputcollid);
154 181332 : COPY_SCALAR_FIELD(aggtranstype);
155 181332 : COPY_NODE_FIELD(aggargtypes);
156 181332 : COPY_NODE_FIELD(aggdirectargs);
157 181332 : COPY_NODE_FIELD(args);
158 181332 : COPY_NODE_FIELD(aggorder);
159 181332 : COPY_NODE_FIELD(aggdistinct);
160 181332 : COPY_NODE_FIELD(aggfilter);
161 181332 : COPY_SCALAR_FIELD(aggstar);
162 181332 : COPY_SCALAR_FIELD(aggvariadic);
163 181332 : COPY_SCALAR_FIELD(aggkind);
164 181332 : COPY_SCALAR_FIELD(aggpresorted);
165 181332 : COPY_SCALAR_FIELD(agglevelsup);
166 181332 : COPY_SCALAR_FIELD(aggsplit);
167 181332 : COPY_SCALAR_FIELD(aggno);
168 181332 : COPY_SCALAR_FIELD(aggtransno);
169 181332 : COPY_LOCATION_FIELD(location);
170 :
171 181332 : return newnode;
172 : }
173 :
174 : static GroupingFunc *
175 1356 : _copyGroupingFunc(const GroupingFunc *from)
176 : {
177 1356 : GroupingFunc *newnode = makeNode(GroupingFunc);
178 :
179 1356 : COPY_NODE_FIELD(args);
180 1356 : COPY_NODE_FIELD(refs);
181 1356 : COPY_NODE_FIELD(cols);
182 1356 : COPY_SCALAR_FIELD(agglevelsup);
183 1356 : COPY_LOCATION_FIELD(location);
184 :
185 1356 : return newnode;
186 : }
187 :
188 : static WindowFunc *
189 7668 : _copyWindowFunc(const WindowFunc *from)
190 : {
191 7668 : WindowFunc *newnode = makeNode(WindowFunc);
192 :
193 7668 : COPY_SCALAR_FIELD(winfnoid);
194 7668 : COPY_SCALAR_FIELD(wintype);
195 7668 : COPY_SCALAR_FIELD(wincollid);
196 7668 : COPY_SCALAR_FIELD(inputcollid);
197 7668 : COPY_NODE_FIELD(args);
198 7668 : COPY_NODE_FIELD(aggfilter);
199 7668 : COPY_NODE_FIELD(runCondition);
200 7668 : COPY_SCALAR_FIELD(winref);
201 7668 : COPY_SCALAR_FIELD(winstar);
202 7668 : COPY_SCALAR_FIELD(winagg);
203 7668 : COPY_LOCATION_FIELD(location);
204 :
205 7668 : return newnode;
206 : }
207 :
208 : static WindowFuncRunCondition *
209 522 : _copyWindowFuncRunCondition(const WindowFuncRunCondition *from)
210 : {
211 522 : WindowFuncRunCondition *newnode = makeNode(WindowFuncRunCondition);
212 :
213 522 : COPY_SCALAR_FIELD(opno);
214 522 : COPY_SCALAR_FIELD(inputcollid);
215 522 : COPY_SCALAR_FIELD(wfunc_left);
216 522 : COPY_NODE_FIELD(arg);
217 :
218 522 : return newnode;
219 : }
220 :
221 : static MergeSupportFunc *
222 1698 : _copyMergeSupportFunc(const MergeSupportFunc *from)
223 : {
224 1698 : MergeSupportFunc *newnode = makeNode(MergeSupportFunc);
225 :
226 1698 : COPY_SCALAR_FIELD(msftype);
227 1698 : COPY_SCALAR_FIELD(msfcollid);
228 1698 : COPY_LOCATION_FIELD(location);
229 :
230 1698 : return newnode;
231 : }
232 :
233 : static SubscriptingRef *
234 42936 : _copySubscriptingRef(const SubscriptingRef *from)
235 : {
236 42936 : SubscriptingRef *newnode = makeNode(SubscriptingRef);
237 :
238 42936 : COPY_SCALAR_FIELD(refcontainertype);
239 42936 : COPY_SCALAR_FIELD(refelemtype);
240 42936 : COPY_SCALAR_FIELD(refrestype);
241 42936 : COPY_SCALAR_FIELD(reftypmod);
242 42936 : COPY_SCALAR_FIELD(refcollid);
243 42936 : COPY_NODE_FIELD(refupperindexpr);
244 42936 : COPY_NODE_FIELD(reflowerindexpr);
245 42936 : COPY_NODE_FIELD(refexpr);
246 42936 : COPY_NODE_FIELD(refassgnexpr);
247 :
248 42936 : return newnode;
249 : }
250 :
251 : static FuncExpr *
252 866674 : _copyFuncExpr(const FuncExpr *from)
253 : {
254 866674 : FuncExpr *newnode = makeNode(FuncExpr);
255 :
256 866674 : COPY_SCALAR_FIELD(funcid);
257 866674 : COPY_SCALAR_FIELD(funcresulttype);
258 866674 : COPY_SCALAR_FIELD(funcretset);
259 866674 : COPY_SCALAR_FIELD(funcvariadic);
260 866674 : COPY_SCALAR_FIELD(funcformat);
261 866674 : COPY_SCALAR_FIELD(funccollid);
262 866674 : COPY_SCALAR_FIELD(inputcollid);
263 866674 : COPY_NODE_FIELD(args);
264 866674 : COPY_LOCATION_FIELD(location);
265 :
266 866674 : return newnode;
267 : }
268 :
269 : static NamedArgExpr *
270 96912 : _copyNamedArgExpr(const NamedArgExpr *from)
271 : {
272 96912 : NamedArgExpr *newnode = makeNode(NamedArgExpr);
273 :
274 96912 : COPY_NODE_FIELD(arg);
275 96912 : COPY_STRING_FIELD(name);
276 96912 : COPY_SCALAR_FIELD(argnumber);
277 96912 : COPY_LOCATION_FIELD(location);
278 :
279 96912 : return newnode;
280 : }
281 :
282 : static OpExpr *
283 1749564 : _copyOpExpr(const OpExpr *from)
284 : {
285 1749564 : OpExpr *newnode = makeNode(OpExpr);
286 :
287 1749564 : COPY_SCALAR_FIELD(opno);
288 1749564 : COPY_SCALAR_FIELD(opfuncid);
289 1749564 : COPY_SCALAR_FIELD(opresulttype);
290 1749564 : COPY_SCALAR_FIELD(opretset);
291 1749564 : COPY_SCALAR_FIELD(opcollid);
292 1749564 : COPY_SCALAR_FIELD(inputcollid);
293 1749564 : COPY_NODE_FIELD(args);
294 1749564 : COPY_LOCATION_FIELD(location);
295 :
296 1749564 : return newnode;
297 : }
298 :
299 : static DistinctExpr *
300 1860 : _copyDistinctExpr(const DistinctExpr *from)
301 : {
302 1860 : DistinctExpr *newnode = makeNode(DistinctExpr);
303 :
304 1860 : COPY_SCALAR_FIELD(opno);
305 1860 : COPY_SCALAR_FIELD(opfuncid);
306 1860 : COPY_SCALAR_FIELD(opresulttype);
307 1860 : COPY_SCALAR_FIELD(opretset);
308 1860 : COPY_SCALAR_FIELD(opcollid);
309 1860 : COPY_SCALAR_FIELD(inputcollid);
310 1860 : COPY_NODE_FIELD(args);
311 1860 : COPY_LOCATION_FIELD(location);
312 :
313 1860 : return newnode;
314 : }
315 :
316 : static NullIfExpr *
317 324 : _copyNullIfExpr(const NullIfExpr *from)
318 : {
319 324 : NullIfExpr *newnode = makeNode(NullIfExpr);
320 :
321 324 : COPY_SCALAR_FIELD(opno);
322 324 : COPY_SCALAR_FIELD(opfuncid);
323 324 : COPY_SCALAR_FIELD(opresulttype);
324 324 : COPY_SCALAR_FIELD(opretset);
325 324 : COPY_SCALAR_FIELD(opcollid);
326 324 : COPY_SCALAR_FIELD(inputcollid);
327 324 : COPY_NODE_FIELD(args);
328 324 : COPY_LOCATION_FIELD(location);
329 :
330 324 : return newnode;
331 : }
332 :
333 : static ScalarArrayOpExpr *
334 78930 : _copyScalarArrayOpExpr(const ScalarArrayOpExpr *from)
335 : {
336 78930 : ScalarArrayOpExpr *newnode = makeNode(ScalarArrayOpExpr);
337 :
338 78930 : COPY_SCALAR_FIELD(opno);
339 78930 : COPY_SCALAR_FIELD(opfuncid);
340 78930 : COPY_SCALAR_FIELD(hashfuncid);
341 78930 : COPY_SCALAR_FIELD(negfuncid);
342 78930 : COPY_SCALAR_FIELD(useOr);
343 78930 : COPY_SCALAR_FIELD(inputcollid);
344 78930 : COPY_NODE_FIELD(args);
345 78930 : COPY_LOCATION_FIELD(location);
346 :
347 78930 : return newnode;
348 : }
349 :
350 : static BoolExpr *
351 425392 : _copyBoolExpr(const BoolExpr *from)
352 : {
353 425392 : BoolExpr *newnode = makeNode(BoolExpr);
354 :
355 425392 : COPY_SCALAR_FIELD(boolop);
356 425392 : COPY_NODE_FIELD(args);
357 425392 : COPY_LOCATION_FIELD(location);
358 :
359 425392 : return newnode;
360 : }
361 :
362 : static SubLink *
363 96576 : _copySubLink(const SubLink *from)
364 : {
365 96576 : SubLink *newnode = makeNode(SubLink);
366 :
367 96576 : COPY_SCALAR_FIELD(subLinkType);
368 96576 : COPY_SCALAR_FIELD(subLinkId);
369 96576 : COPY_NODE_FIELD(testexpr);
370 96576 : COPY_NODE_FIELD(operName);
371 96576 : COPY_NODE_FIELD(subselect);
372 96576 : COPY_LOCATION_FIELD(location);
373 :
374 96576 : return newnode;
375 : }
376 :
377 : static SubPlan *
378 42068 : _copySubPlan(const SubPlan *from)
379 : {
380 42068 : SubPlan *newnode = makeNode(SubPlan);
381 :
382 42068 : COPY_SCALAR_FIELD(subLinkType);
383 42068 : COPY_NODE_FIELD(testexpr);
384 42068 : COPY_NODE_FIELD(paramIds);
385 42068 : COPY_SCALAR_FIELD(plan_id);
386 42068 : COPY_STRING_FIELD(plan_name);
387 42068 : COPY_SCALAR_FIELD(firstColType);
388 42068 : COPY_SCALAR_FIELD(firstColTypmod);
389 42068 : COPY_SCALAR_FIELD(firstColCollation);
390 42068 : COPY_SCALAR_FIELD(useHashTable);
391 42068 : COPY_SCALAR_FIELD(unknownEqFalse);
392 42068 : COPY_SCALAR_FIELD(parallel_safe);
393 42068 : COPY_NODE_FIELD(setParam);
394 42068 : COPY_NODE_FIELD(parParam);
395 42068 : COPY_NODE_FIELD(args);
396 42068 : COPY_SCALAR_FIELD(startup_cost);
397 42068 : COPY_SCALAR_FIELD(per_call_cost);
398 :
399 42068 : return newnode;
400 : }
401 :
402 : static AlternativeSubPlan *
403 0 : _copyAlternativeSubPlan(const AlternativeSubPlan *from)
404 : {
405 0 : AlternativeSubPlan *newnode = makeNode(AlternativeSubPlan);
406 :
407 0 : COPY_NODE_FIELD(subplans);
408 :
409 0 : return newnode;
410 : }
411 :
412 : static FieldSelect *
413 15992 : _copyFieldSelect(const FieldSelect *from)
414 : {
415 15992 : FieldSelect *newnode = makeNode(FieldSelect);
416 :
417 15992 : COPY_NODE_FIELD(arg);
418 15992 : COPY_SCALAR_FIELD(fieldnum);
419 15992 : COPY_SCALAR_FIELD(resulttype);
420 15992 : COPY_SCALAR_FIELD(resulttypmod);
421 15992 : COPY_SCALAR_FIELD(resultcollid);
422 :
423 15992 : return newnode;
424 : }
425 :
426 : static FieldStore *
427 800 : _copyFieldStore(const FieldStore *from)
428 : {
429 800 : FieldStore *newnode = makeNode(FieldStore);
430 :
431 800 : COPY_NODE_FIELD(arg);
432 800 : COPY_NODE_FIELD(newvals);
433 800 : COPY_NODE_FIELD(fieldnums);
434 800 : COPY_SCALAR_FIELD(resulttype);
435 :
436 800 : return newnode;
437 : }
438 :
439 : static RelabelType *
440 302226 : _copyRelabelType(const RelabelType *from)
441 : {
442 302226 : RelabelType *newnode = makeNode(RelabelType);
443 :
444 302226 : COPY_NODE_FIELD(arg);
445 302226 : COPY_SCALAR_FIELD(resulttype);
446 302226 : COPY_SCALAR_FIELD(resulttypmod);
447 302226 : COPY_SCALAR_FIELD(resultcollid);
448 302226 : COPY_SCALAR_FIELD(relabelformat);
449 302226 : COPY_LOCATION_FIELD(location);
450 :
451 302226 : return newnode;
452 : }
453 :
454 : static CoerceViaIO *
455 67938 : _copyCoerceViaIO(const CoerceViaIO *from)
456 : {
457 67938 : CoerceViaIO *newnode = makeNode(CoerceViaIO);
458 :
459 67938 : COPY_NODE_FIELD(arg);
460 67938 : COPY_SCALAR_FIELD(resulttype);
461 67938 : COPY_SCALAR_FIELD(resultcollid);
462 67938 : COPY_SCALAR_FIELD(coerceformat);
463 67938 : COPY_LOCATION_FIELD(location);
464 :
465 67938 : return newnode;
466 : }
467 :
468 : static ArrayCoerceExpr *
469 13222 : _copyArrayCoerceExpr(const ArrayCoerceExpr *from)
470 : {
471 13222 : ArrayCoerceExpr *newnode = makeNode(ArrayCoerceExpr);
472 :
473 13222 : COPY_NODE_FIELD(arg);
474 13222 : COPY_NODE_FIELD(elemexpr);
475 13222 : COPY_SCALAR_FIELD(resulttype);
476 13222 : COPY_SCALAR_FIELD(resulttypmod);
477 13222 : COPY_SCALAR_FIELD(resultcollid);
478 13222 : COPY_SCALAR_FIELD(coerceformat);
479 13222 : COPY_LOCATION_FIELD(location);
480 :
481 13222 : return newnode;
482 : }
483 :
484 : static ConvertRowtypeExpr *
485 764 : _copyConvertRowtypeExpr(const ConvertRowtypeExpr *from)
486 : {
487 764 : ConvertRowtypeExpr *newnode = makeNode(ConvertRowtypeExpr);
488 :
489 764 : COPY_NODE_FIELD(arg);
490 764 : COPY_SCALAR_FIELD(resulttype);
491 764 : COPY_SCALAR_FIELD(convertformat);
492 764 : COPY_LOCATION_FIELD(location);
493 :
494 764 : return newnode;
495 : }
496 :
497 : static CollateExpr *
498 8482 : _copyCollateExpr(const CollateExpr *from)
499 : {
500 8482 : CollateExpr *newnode = makeNode(CollateExpr);
501 :
502 8482 : COPY_NODE_FIELD(arg);
503 8482 : COPY_SCALAR_FIELD(collOid);
504 8482 : COPY_LOCATION_FIELD(location);
505 :
506 8482 : return newnode;
507 : }
508 :
509 : static CaseExpr *
510 188850 : _copyCaseExpr(const CaseExpr *from)
511 : {
512 188850 : CaseExpr *newnode = makeNode(CaseExpr);
513 :
514 188850 : COPY_SCALAR_FIELD(casetype);
515 188850 : COPY_SCALAR_FIELD(casecollid);
516 188850 : COPY_NODE_FIELD(arg);
517 188850 : COPY_NODE_FIELD(args);
518 188850 : COPY_NODE_FIELD(defresult);
519 188850 : COPY_LOCATION_FIELD(location);
520 :
521 188850 : return newnode;
522 : }
523 :
524 : static CaseWhen *
525 345214 : _copyCaseWhen(const CaseWhen *from)
526 : {
527 345214 : CaseWhen *newnode = makeNode(CaseWhen);
528 :
529 345214 : COPY_NODE_FIELD(expr);
530 345214 : COPY_NODE_FIELD(result);
531 345214 : COPY_LOCATION_FIELD(location);
532 :
533 345214 : return newnode;
534 : }
535 :
536 : static CaseTestExpr *
537 110696 : _copyCaseTestExpr(const CaseTestExpr *from)
538 : {
539 110696 : CaseTestExpr *newnode = makeNode(CaseTestExpr);
540 :
541 110696 : COPY_SCALAR_FIELD(typeId);
542 110696 : COPY_SCALAR_FIELD(typeMod);
543 110696 : COPY_SCALAR_FIELD(collation);
544 :
545 110696 : return newnode;
546 : }
547 :
548 : static ArrayExpr *
549 44228 : _copyArrayExpr(const ArrayExpr *from)
550 : {
551 44228 : ArrayExpr *newnode = makeNode(ArrayExpr);
552 :
553 44228 : COPY_SCALAR_FIELD(array_typeid);
554 44228 : COPY_SCALAR_FIELD(array_collid);
555 44228 : COPY_SCALAR_FIELD(element_typeid);
556 44228 : COPY_NODE_FIELD(elements);
557 44228 : COPY_SCALAR_FIELD(multidims);
558 44228 : COPY_LOCATION_FIELD(location);
559 :
560 44228 : return newnode;
561 : }
562 :
563 : static RowExpr *
564 16266 : _copyRowExpr(const RowExpr *from)
565 : {
566 16266 : RowExpr *newnode = makeNode(RowExpr);
567 :
568 16266 : COPY_NODE_FIELD(args);
569 16266 : COPY_SCALAR_FIELD(row_typeid);
570 16266 : COPY_SCALAR_FIELD(row_format);
571 16266 : COPY_NODE_FIELD(colnames);
572 16266 : COPY_LOCATION_FIELD(location);
573 :
574 16266 : return newnode;
575 : }
576 :
577 : static RowCompareExpr *
578 420 : _copyRowCompareExpr(const RowCompareExpr *from)
579 : {
580 420 : RowCompareExpr *newnode = makeNode(RowCompareExpr);
581 :
582 420 : COPY_SCALAR_FIELD(rctype);
583 420 : COPY_NODE_FIELD(opnos);
584 420 : COPY_NODE_FIELD(opfamilies);
585 420 : COPY_NODE_FIELD(inputcollids);
586 420 : COPY_NODE_FIELD(largs);
587 420 : COPY_NODE_FIELD(rargs);
588 :
589 420 : return newnode;
590 : }
591 :
592 : static CoalesceExpr *
593 18996 : _copyCoalesceExpr(const CoalesceExpr *from)
594 : {
595 18996 : CoalesceExpr *newnode = makeNode(CoalesceExpr);
596 :
597 18996 : COPY_SCALAR_FIELD(coalescetype);
598 18996 : COPY_SCALAR_FIELD(coalescecollid);
599 18996 : COPY_NODE_FIELD(args);
600 18996 : COPY_LOCATION_FIELD(location);
601 :
602 18996 : return newnode;
603 : }
604 :
605 : static MinMaxExpr *
606 1362 : _copyMinMaxExpr(const MinMaxExpr *from)
607 : {
608 1362 : MinMaxExpr *newnode = makeNode(MinMaxExpr);
609 :
610 1362 : COPY_SCALAR_FIELD(minmaxtype);
611 1362 : COPY_SCALAR_FIELD(minmaxcollid);
612 1362 : COPY_SCALAR_FIELD(inputcollid);
613 1362 : COPY_SCALAR_FIELD(op);
614 1362 : COPY_NODE_FIELD(args);
615 1362 : COPY_LOCATION_FIELD(location);
616 :
617 1362 : return newnode;
618 : }
619 :
620 : static SQLValueFunction *
621 29694 : _copySQLValueFunction(const SQLValueFunction *from)
622 : {
623 29694 : SQLValueFunction *newnode = makeNode(SQLValueFunction);
624 :
625 29694 : COPY_SCALAR_FIELD(op);
626 29694 : COPY_SCALAR_FIELD(type);
627 29694 : COPY_SCALAR_FIELD(typmod);
628 29694 : COPY_LOCATION_FIELD(location);
629 :
630 29694 : return newnode;
631 : }
632 :
633 : static XmlExpr *
634 2278 : _copyXmlExpr(const XmlExpr *from)
635 : {
636 2278 : XmlExpr *newnode = makeNode(XmlExpr);
637 :
638 2278 : COPY_SCALAR_FIELD(op);
639 2278 : COPY_STRING_FIELD(name);
640 2278 : COPY_NODE_FIELD(named_args);
641 2278 : COPY_NODE_FIELD(arg_names);
642 2278 : COPY_NODE_FIELD(args);
643 2278 : COPY_SCALAR_FIELD(xmloption);
644 2278 : COPY_SCALAR_FIELD(indent);
645 2278 : COPY_SCALAR_FIELD(type);
646 2278 : COPY_SCALAR_FIELD(typmod);
647 2278 : COPY_LOCATION_FIELD(location);
648 :
649 2278 : return newnode;
650 : }
651 :
652 : static JsonFormat *
653 28380 : _copyJsonFormat(const JsonFormat *from)
654 : {
655 28380 : JsonFormat *newnode = makeNode(JsonFormat);
656 :
657 28380 : COPY_SCALAR_FIELD(format_type);
658 28380 : COPY_SCALAR_FIELD(encoding);
659 28380 : COPY_LOCATION_FIELD(location);
660 :
661 28380 : return newnode;
662 : }
663 :
664 : static JsonReturning *
665 11894 : _copyJsonReturning(const JsonReturning *from)
666 : {
667 11894 : JsonReturning *newnode = makeNode(JsonReturning);
668 :
669 11894 : COPY_NODE_FIELD(format);
670 11894 : COPY_SCALAR_FIELD(typid);
671 11894 : COPY_SCALAR_FIELD(typmod);
672 :
673 11894 : return newnode;
674 : }
675 :
676 : static JsonValueExpr *
677 6690 : _copyJsonValueExpr(const JsonValueExpr *from)
678 : {
679 6690 : JsonValueExpr *newnode = makeNode(JsonValueExpr);
680 :
681 6690 : COPY_NODE_FIELD(raw_expr);
682 6690 : COPY_NODE_FIELD(formatted_expr);
683 6690 : COPY_NODE_FIELD(format);
684 :
685 6690 : return newnode;
686 : }
687 :
688 : static JsonConstructorExpr *
689 2726 : _copyJsonConstructorExpr(const JsonConstructorExpr *from)
690 : {
691 2726 : JsonConstructorExpr *newnode = makeNode(JsonConstructorExpr);
692 :
693 2726 : COPY_SCALAR_FIELD(type);
694 2726 : COPY_NODE_FIELD(args);
695 2726 : COPY_NODE_FIELD(func);
696 2726 : COPY_NODE_FIELD(coercion);
697 2726 : COPY_NODE_FIELD(returning);
698 2726 : COPY_SCALAR_FIELD(absent_on_null);
699 2726 : COPY_SCALAR_FIELD(unique);
700 2726 : COPY_LOCATION_FIELD(location);
701 :
702 2726 : return newnode;
703 : }
704 :
705 : static JsonIsPredicate *
706 1026 : _copyJsonIsPredicate(const JsonIsPredicate *from)
707 : {
708 1026 : JsonIsPredicate *newnode = makeNode(JsonIsPredicate);
709 :
710 1026 : COPY_NODE_FIELD(expr);
711 1026 : COPY_NODE_FIELD(format);
712 1026 : COPY_SCALAR_FIELD(item_type);
713 1026 : COPY_SCALAR_FIELD(unique_keys);
714 1026 : COPY_LOCATION_FIELD(location);
715 :
716 1026 : return newnode;
717 : }
718 :
719 : static JsonBehavior *
720 10350 : _copyJsonBehavior(const JsonBehavior *from)
721 : {
722 10350 : JsonBehavior *newnode = makeNode(JsonBehavior);
723 :
724 10350 : COPY_SCALAR_FIELD(btype);
725 10350 : COPY_NODE_FIELD(expr);
726 10350 : COPY_SCALAR_FIELD(coerce);
727 10350 : COPY_LOCATION_FIELD(location);
728 :
729 10350 : return newnode;
730 : }
731 :
732 : static JsonExpr *
733 5318 : _copyJsonExpr(const JsonExpr *from)
734 : {
735 5318 : JsonExpr *newnode = makeNode(JsonExpr);
736 :
737 5318 : COPY_SCALAR_FIELD(op);
738 5318 : COPY_STRING_FIELD(column_name);
739 5318 : COPY_NODE_FIELD(formatted_expr);
740 5318 : COPY_NODE_FIELD(format);
741 5318 : COPY_NODE_FIELD(path_spec);
742 5318 : COPY_NODE_FIELD(returning);
743 5318 : COPY_NODE_FIELD(passing_names);
744 5318 : COPY_NODE_FIELD(passing_values);
745 5318 : COPY_NODE_FIELD(on_empty);
746 5318 : COPY_NODE_FIELD(on_error);
747 5318 : COPY_SCALAR_FIELD(use_io_coercion);
748 5318 : COPY_SCALAR_FIELD(use_json_coercion);
749 5318 : COPY_SCALAR_FIELD(wrapper);
750 5318 : COPY_SCALAR_FIELD(omit_quotes);
751 5318 : COPY_SCALAR_FIELD(collation);
752 5318 : COPY_LOCATION_FIELD(location);
753 :
754 5318 : return newnode;
755 : }
756 :
757 : static JsonTablePath *
758 1214 : _copyJsonTablePath(const JsonTablePath *from)
759 : {
760 1214 : JsonTablePath *newnode = makeNode(JsonTablePath);
761 :
762 1214 : COPY_NODE_FIELD(value);
763 1214 : COPY_STRING_FIELD(name);
764 :
765 1214 : return newnode;
766 : }
767 :
768 : static JsonTablePathScan *
769 1214 : _copyJsonTablePathScan(const JsonTablePathScan *from)
770 : {
771 1214 : JsonTablePathScan *newnode = makeNode(JsonTablePathScan);
772 :
773 1214 : COPY_NODE_FIELD(path);
774 1214 : COPY_SCALAR_FIELD(errorOnError);
775 1214 : COPY_NODE_FIELD(child);
776 1214 : COPY_SCALAR_FIELD(colMin);
777 1214 : COPY_SCALAR_FIELD(colMax);
778 :
779 1214 : return newnode;
780 : }
781 :
782 : static JsonTableSiblingJoin *
783 120 : _copyJsonTableSiblingJoin(const JsonTableSiblingJoin *from)
784 : {
785 120 : JsonTableSiblingJoin *newnode = makeNode(JsonTableSiblingJoin);
786 :
787 120 : COPY_NODE_FIELD(lplan);
788 120 : COPY_NODE_FIELD(rplan);
789 :
790 120 : return newnode;
791 : }
792 :
793 : static NullTest *
794 78440 : _copyNullTest(const NullTest *from)
795 : {
796 78440 : NullTest *newnode = makeNode(NullTest);
797 :
798 78440 : COPY_NODE_FIELD(arg);
799 78440 : COPY_SCALAR_FIELD(nulltesttype);
800 78440 : COPY_SCALAR_FIELD(argisrow);
801 78440 : COPY_LOCATION_FIELD(location);
802 :
803 78440 : return newnode;
804 : }
805 :
806 : static BooleanTest *
807 3944 : _copyBooleanTest(const BooleanTest *from)
808 : {
809 3944 : BooleanTest *newnode = makeNode(BooleanTest);
810 :
811 3944 : COPY_NODE_FIELD(arg);
812 3944 : COPY_SCALAR_FIELD(booltesttype);
813 3944 : COPY_LOCATION_FIELD(location);
814 :
815 3944 : return newnode;
816 : }
817 :
818 : static MergeAction *
819 8178 : _copyMergeAction(const MergeAction *from)
820 : {
821 8178 : MergeAction *newnode = makeNode(MergeAction);
822 :
823 8178 : COPY_SCALAR_FIELD(matchKind);
824 8178 : COPY_SCALAR_FIELD(commandType);
825 8178 : COPY_SCALAR_FIELD(override);
826 8178 : COPY_NODE_FIELD(qual);
827 8178 : COPY_NODE_FIELD(targetList);
828 8178 : COPY_NODE_FIELD(updateColnos);
829 :
830 8178 : return newnode;
831 : }
832 :
833 : static CoerceToDomain *
834 77814 : _copyCoerceToDomain(const CoerceToDomain *from)
835 : {
836 77814 : CoerceToDomain *newnode = makeNode(CoerceToDomain);
837 :
838 77814 : COPY_NODE_FIELD(arg);
839 77814 : COPY_SCALAR_FIELD(resulttype);
840 77814 : COPY_SCALAR_FIELD(resulttypmod);
841 77814 : COPY_SCALAR_FIELD(resultcollid);
842 77814 : COPY_SCALAR_FIELD(coercionformat);
843 77814 : COPY_LOCATION_FIELD(location);
844 :
845 77814 : return newnode;
846 : }
847 :
848 : static CoerceToDomainValue *
849 2202 : _copyCoerceToDomainValue(const CoerceToDomainValue *from)
850 : {
851 2202 : CoerceToDomainValue *newnode = makeNode(CoerceToDomainValue);
852 :
853 2202 : COPY_SCALAR_FIELD(typeId);
854 2202 : COPY_SCALAR_FIELD(typeMod);
855 2202 : COPY_SCALAR_FIELD(collation);
856 2202 : COPY_LOCATION_FIELD(location);
857 :
858 2202 : return newnode;
859 : }
860 :
861 : static SetToDefault *
862 1848 : _copySetToDefault(const SetToDefault *from)
863 : {
864 1848 : SetToDefault *newnode = makeNode(SetToDefault);
865 :
866 1848 : COPY_SCALAR_FIELD(typeId);
867 1848 : COPY_SCALAR_FIELD(typeMod);
868 1848 : COPY_SCALAR_FIELD(collation);
869 1848 : COPY_LOCATION_FIELD(location);
870 :
871 1848 : return newnode;
872 : }
873 :
874 : static CurrentOfExpr *
875 1752 : _copyCurrentOfExpr(const CurrentOfExpr *from)
876 : {
877 1752 : CurrentOfExpr *newnode = makeNode(CurrentOfExpr);
878 :
879 1752 : COPY_SCALAR_FIELD(cvarno);
880 1752 : COPY_STRING_FIELD(cursor_name);
881 1752 : COPY_SCALAR_FIELD(cursor_param);
882 :
883 1752 : return newnode;
884 : }
885 :
886 : static NextValueExpr *
887 1360 : _copyNextValueExpr(const NextValueExpr *from)
888 : {
889 1360 : NextValueExpr *newnode = makeNode(NextValueExpr);
890 :
891 1360 : COPY_SCALAR_FIELD(seqid);
892 1360 : COPY_SCALAR_FIELD(typeId);
893 :
894 1360 : return newnode;
895 : }
896 :
897 : static InferenceElem *
898 1904 : _copyInferenceElem(const InferenceElem *from)
899 : {
900 1904 : InferenceElem *newnode = makeNode(InferenceElem);
901 :
902 1904 : COPY_NODE_FIELD(expr);
903 1904 : COPY_SCALAR_FIELD(infercollid);
904 1904 : COPY_SCALAR_FIELD(inferopclass);
905 :
906 1904 : return newnode;
907 : }
908 :
909 : static TargetEntry *
910 7432540 : _copyTargetEntry(const TargetEntry *from)
911 : {
912 7432540 : TargetEntry *newnode = makeNode(TargetEntry);
913 :
914 7432540 : COPY_NODE_FIELD(expr);
915 7432540 : COPY_SCALAR_FIELD(resno);
916 7432540 : COPY_STRING_FIELD(resname);
917 7432540 : COPY_SCALAR_FIELD(ressortgroupref);
918 7432540 : COPY_SCALAR_FIELD(resorigtbl);
919 7432540 : COPY_SCALAR_FIELD(resorigcol);
920 7432540 : COPY_SCALAR_FIELD(resjunk);
921 :
922 7432540 : return newnode;
923 : }
924 :
925 : static RangeTblRef *
926 734196 : _copyRangeTblRef(const RangeTblRef *from)
927 : {
928 734196 : RangeTblRef *newnode = makeNode(RangeTblRef);
929 :
930 734196 : COPY_SCALAR_FIELD(rtindex);
931 :
932 734196 : return newnode;
933 : }
934 :
935 : static JoinExpr *
936 203904 : _copyJoinExpr(const JoinExpr *from)
937 : {
938 203904 : JoinExpr *newnode = makeNode(JoinExpr);
939 :
940 203904 : COPY_SCALAR_FIELD(jointype);
941 203904 : COPY_SCALAR_FIELD(isNatural);
942 203904 : COPY_NODE_FIELD(larg);
943 203904 : COPY_NODE_FIELD(rarg);
944 203904 : COPY_NODE_FIELD(usingClause);
945 203904 : COPY_NODE_FIELD(join_using_alias);
946 203904 : COPY_NODE_FIELD(quals);
947 203904 : COPY_NODE_FIELD(alias);
948 203904 : COPY_SCALAR_FIELD(rtindex);
949 :
950 203904 : return newnode;
951 : }
952 :
953 : static FromExpr *
954 812800 : _copyFromExpr(const FromExpr *from)
955 : {
956 812800 : FromExpr *newnode = makeNode(FromExpr);
957 :
958 812800 : COPY_NODE_FIELD(fromlist);
959 812800 : COPY_NODE_FIELD(quals);
960 :
961 812800 : return newnode;
962 : }
963 :
964 : static OnConflictExpr *
965 1870 : _copyOnConflictExpr(const OnConflictExpr *from)
966 : {
967 1870 : OnConflictExpr *newnode = makeNode(OnConflictExpr);
968 :
969 1870 : COPY_SCALAR_FIELD(action);
970 1870 : COPY_NODE_FIELD(arbiterElems);
971 1870 : COPY_NODE_FIELD(arbiterWhere);
972 1870 : COPY_SCALAR_FIELD(constraint);
973 1870 : COPY_NODE_FIELD(onConflictSet);
974 1870 : COPY_NODE_FIELD(onConflictWhere);
975 1870 : COPY_SCALAR_FIELD(exclRelIndex);
976 1870 : COPY_NODE_FIELD(exclRelTlist);
977 :
978 1870 : return newnode;
979 : }
980 :
981 : static Query *
982 1179130 : _copyQuery(const Query *from)
983 : {
984 1179130 : Query *newnode = makeNode(Query);
985 :
986 1179130 : COPY_SCALAR_FIELD(commandType);
987 1179130 : COPY_SCALAR_FIELD(querySource);
988 1179130 : COPY_SCALAR_FIELD(queryId);
989 1179130 : COPY_SCALAR_FIELD(canSetTag);
990 1179130 : COPY_NODE_FIELD(utilityStmt);
991 1179130 : COPY_SCALAR_FIELD(resultRelation);
992 1179130 : COPY_SCALAR_FIELD(hasAggs);
993 1179130 : COPY_SCALAR_FIELD(hasWindowFuncs);
994 1179130 : COPY_SCALAR_FIELD(hasTargetSRFs);
995 1179130 : COPY_SCALAR_FIELD(hasSubLinks);
996 1179130 : COPY_SCALAR_FIELD(hasDistinctOn);
997 1179130 : COPY_SCALAR_FIELD(hasRecursive);
998 1179130 : COPY_SCALAR_FIELD(hasModifyingCTE);
999 1179130 : COPY_SCALAR_FIELD(hasForUpdate);
1000 1179130 : COPY_SCALAR_FIELD(hasRowSecurity);
1001 1179130 : COPY_SCALAR_FIELD(hasGroupRTE);
1002 1179130 : COPY_SCALAR_FIELD(isReturn);
1003 1179130 : COPY_NODE_FIELD(cteList);
1004 1179130 : COPY_NODE_FIELD(rtable);
1005 1179130 : COPY_NODE_FIELD(rteperminfos);
1006 1179130 : COPY_NODE_FIELD(jointree);
1007 1179130 : COPY_NODE_FIELD(mergeActionList);
1008 1179130 : COPY_SCALAR_FIELD(mergeTargetRelation);
1009 1179130 : COPY_NODE_FIELD(mergeJoinCondition);
1010 1179130 : COPY_NODE_FIELD(targetList);
1011 1179130 : COPY_SCALAR_FIELD(override);
1012 1179130 : COPY_NODE_FIELD(onConflict);
1013 1179130 : COPY_NODE_FIELD(returningList);
1014 1179130 : COPY_NODE_FIELD(groupClause);
1015 1179130 : COPY_SCALAR_FIELD(groupDistinct);
1016 1179130 : COPY_NODE_FIELD(groupingSets);
1017 1179130 : COPY_NODE_FIELD(havingQual);
1018 1179130 : COPY_NODE_FIELD(windowClause);
1019 1179130 : COPY_NODE_FIELD(distinctClause);
1020 1179130 : COPY_NODE_FIELD(sortClause);
1021 1179130 : COPY_NODE_FIELD(limitOffset);
1022 1179130 : COPY_NODE_FIELD(limitCount);
1023 1179130 : COPY_SCALAR_FIELD(limitOption);
1024 1179130 : COPY_NODE_FIELD(rowMarks);
1025 1179130 : COPY_NODE_FIELD(setOperations);
1026 1179130 : COPY_NODE_FIELD(constraintDeps);
1027 1179130 : COPY_NODE_FIELD(withCheckOptions);
1028 1179130 : COPY_LOCATION_FIELD(stmt_location);
1029 1179130 : COPY_LOCATION_FIELD(stmt_len);
1030 :
1031 1179130 : return newnode;
1032 : }
1033 :
1034 : static TypeName *
1035 752452 : _copyTypeName(const TypeName *from)
1036 : {
1037 752452 : TypeName *newnode = makeNode(TypeName);
1038 :
1039 752452 : COPY_NODE_FIELD(names);
1040 752452 : COPY_SCALAR_FIELD(typeOid);
1041 752452 : COPY_SCALAR_FIELD(setof);
1042 752452 : COPY_SCALAR_FIELD(pct_type);
1043 752452 : COPY_NODE_FIELD(typmods);
1044 752452 : COPY_SCALAR_FIELD(typemod);
1045 752452 : COPY_NODE_FIELD(arrayBounds);
1046 752452 : COPY_LOCATION_FIELD(location);
1047 :
1048 752452 : return newnode;
1049 : }
1050 :
1051 : static ColumnRef *
1052 1937358 : _copyColumnRef(const ColumnRef *from)
1053 : {
1054 1937358 : ColumnRef *newnode = makeNode(ColumnRef);
1055 :
1056 1937358 : COPY_NODE_FIELD(fields);
1057 1937358 : COPY_LOCATION_FIELD(location);
1058 :
1059 1937358 : return newnode;
1060 : }
1061 :
1062 : static ParamRef *
1063 175178 : _copyParamRef(const ParamRef *from)
1064 : {
1065 175178 : ParamRef *newnode = makeNode(ParamRef);
1066 :
1067 175178 : COPY_SCALAR_FIELD(number);
1068 175178 : COPY_LOCATION_FIELD(location);
1069 :
1070 175178 : return newnode;
1071 : }
1072 :
1073 : static A_Expr *
1074 675330 : _copyA_Expr(const A_Expr *from)
1075 : {
1076 675330 : A_Expr *newnode = makeNode(A_Expr);
1077 :
1078 675330 : COPY_SCALAR_FIELD(kind);
1079 675330 : COPY_NODE_FIELD(name);
1080 675330 : COPY_NODE_FIELD(lexpr);
1081 675330 : COPY_NODE_FIELD(rexpr);
1082 675330 : COPY_LOCATION_FIELD(location);
1083 :
1084 675330 : return newnode;
1085 : }
1086 :
1087 : static TypeCast *
1088 334500 : _copyTypeCast(const TypeCast *from)
1089 : {
1090 334500 : TypeCast *newnode = makeNode(TypeCast);
1091 :
1092 334500 : COPY_NODE_FIELD(arg);
1093 334500 : COPY_NODE_FIELD(typeName);
1094 334500 : COPY_LOCATION_FIELD(location);
1095 :
1096 334500 : return newnode;
1097 : }
1098 :
1099 : static CollateClause *
1100 9744 : _copyCollateClause(const CollateClause *from)
1101 : {
1102 9744 : CollateClause *newnode = makeNode(CollateClause);
1103 :
1104 9744 : COPY_NODE_FIELD(arg);
1105 9744 : COPY_NODE_FIELD(collname);
1106 9744 : COPY_LOCATION_FIELD(location);
1107 :
1108 9744 : return newnode;
1109 : }
1110 :
1111 : static RoleSpec *
1112 65550 : _copyRoleSpec(const RoleSpec *from)
1113 : {
1114 65550 : RoleSpec *newnode = makeNode(RoleSpec);
1115 :
1116 65550 : COPY_SCALAR_FIELD(roletype);
1117 65550 : COPY_STRING_FIELD(rolename);
1118 65550 : COPY_LOCATION_FIELD(location);
1119 :
1120 65550 : return newnode;
1121 : }
1122 :
1123 : static FuncCall *
1124 421650 : _copyFuncCall(const FuncCall *from)
1125 : {
1126 421650 : FuncCall *newnode = makeNode(FuncCall);
1127 :
1128 421650 : COPY_NODE_FIELD(funcname);
1129 421650 : COPY_NODE_FIELD(args);
1130 421650 : COPY_NODE_FIELD(agg_order);
1131 421650 : COPY_NODE_FIELD(agg_filter);
1132 421650 : COPY_NODE_FIELD(over);
1133 421650 : COPY_SCALAR_FIELD(agg_within_group);
1134 421650 : COPY_SCALAR_FIELD(agg_star);
1135 421650 : COPY_SCALAR_FIELD(agg_distinct);
1136 421650 : COPY_SCALAR_FIELD(func_variadic);
1137 421650 : COPY_SCALAR_FIELD(funcformat);
1138 421650 : COPY_LOCATION_FIELD(location);
1139 :
1140 421650 : return newnode;
1141 : }
1142 :
1143 : static A_Star *
1144 62312 : _copyA_Star(const A_Star *from)
1145 : {
1146 62312 : A_Star *newnode = makeNode(A_Star);
1147 :
1148 :
1149 62312 : return newnode;
1150 : }
1151 :
1152 : static A_Indices *
1153 15098 : _copyA_Indices(const A_Indices *from)
1154 : {
1155 15098 : A_Indices *newnode = makeNode(A_Indices);
1156 :
1157 15098 : COPY_SCALAR_FIELD(is_slice);
1158 15098 : COPY_NODE_FIELD(lidx);
1159 15098 : COPY_NODE_FIELD(uidx);
1160 :
1161 15098 : return newnode;
1162 : }
1163 :
1164 : static A_Indirection *
1165 34732 : _copyA_Indirection(const A_Indirection *from)
1166 : {
1167 34732 : A_Indirection *newnode = makeNode(A_Indirection);
1168 :
1169 34732 : COPY_NODE_FIELD(arg);
1170 34732 : COPY_NODE_FIELD(indirection);
1171 :
1172 34732 : return newnode;
1173 : }
1174 :
1175 : static A_ArrayExpr *
1176 7846 : _copyA_ArrayExpr(const A_ArrayExpr *from)
1177 : {
1178 7846 : A_ArrayExpr *newnode = makeNode(A_ArrayExpr);
1179 :
1180 7846 : COPY_NODE_FIELD(elements);
1181 7846 : COPY_LOCATION_FIELD(location);
1182 :
1183 7846 : return newnode;
1184 : }
1185 :
1186 : static ResTarget *
1187 1280752 : _copyResTarget(const ResTarget *from)
1188 : {
1189 1280752 : ResTarget *newnode = makeNode(ResTarget);
1190 :
1191 1280752 : COPY_STRING_FIELD(name);
1192 1280752 : COPY_NODE_FIELD(indirection);
1193 1280752 : COPY_NODE_FIELD(val);
1194 1280752 : COPY_LOCATION_FIELD(location);
1195 :
1196 1280752 : return newnode;
1197 : }
1198 :
1199 : static MultiAssignRef *
1200 402 : _copyMultiAssignRef(const MultiAssignRef *from)
1201 : {
1202 402 : MultiAssignRef *newnode = makeNode(MultiAssignRef);
1203 :
1204 402 : COPY_NODE_FIELD(source);
1205 402 : COPY_SCALAR_FIELD(colno);
1206 402 : COPY_SCALAR_FIELD(ncolumns);
1207 :
1208 402 : return newnode;
1209 : }
1210 :
1211 : static SortBy *
1212 95560 : _copySortBy(const SortBy *from)
1213 : {
1214 95560 : SortBy *newnode = makeNode(SortBy);
1215 :
1216 95560 : COPY_NODE_FIELD(node);
1217 95560 : COPY_SCALAR_FIELD(sortby_dir);
1218 95560 : COPY_SCALAR_FIELD(sortby_nulls);
1219 95560 : COPY_NODE_FIELD(useOp);
1220 95560 : COPY_LOCATION_FIELD(location);
1221 :
1222 95560 : return newnode;
1223 : }
1224 :
1225 : static WindowDef *
1226 4128 : _copyWindowDef(const WindowDef *from)
1227 : {
1228 4128 : WindowDef *newnode = makeNode(WindowDef);
1229 :
1230 4128 : COPY_STRING_FIELD(name);
1231 4128 : COPY_STRING_FIELD(refname);
1232 4128 : COPY_NODE_FIELD(partitionClause);
1233 4128 : COPY_NODE_FIELD(orderClause);
1234 4128 : COPY_SCALAR_FIELD(frameOptions);
1235 4128 : COPY_NODE_FIELD(startOffset);
1236 4128 : COPY_NODE_FIELD(endOffset);
1237 4128 : COPY_LOCATION_FIELD(location);
1238 :
1239 4128 : return newnode;
1240 : }
1241 :
1242 : static RangeSubselect *
1243 17678 : _copyRangeSubselect(const RangeSubselect *from)
1244 : {
1245 17678 : RangeSubselect *newnode = makeNode(RangeSubselect);
1246 :
1247 17678 : COPY_SCALAR_FIELD(lateral);
1248 17678 : COPY_NODE_FIELD(subquery);
1249 17678 : COPY_NODE_FIELD(alias);
1250 :
1251 17678 : return newnode;
1252 : }
1253 :
1254 : static RangeFunction *
1255 47144 : _copyRangeFunction(const RangeFunction *from)
1256 : {
1257 47144 : RangeFunction *newnode = makeNode(RangeFunction);
1258 :
1259 47144 : COPY_SCALAR_FIELD(lateral);
1260 47144 : COPY_SCALAR_FIELD(ordinality);
1261 47144 : COPY_SCALAR_FIELD(is_rowsfrom);
1262 47144 : COPY_NODE_FIELD(functions);
1263 47144 : COPY_NODE_FIELD(alias);
1264 47144 : COPY_NODE_FIELD(coldeflist);
1265 :
1266 47144 : return newnode;
1267 : }
1268 :
1269 : static RangeTableFunc *
1270 248 : _copyRangeTableFunc(const RangeTableFunc *from)
1271 : {
1272 248 : RangeTableFunc *newnode = makeNode(RangeTableFunc);
1273 :
1274 248 : COPY_SCALAR_FIELD(lateral);
1275 248 : COPY_NODE_FIELD(docexpr);
1276 248 : COPY_NODE_FIELD(rowexpr);
1277 248 : COPY_NODE_FIELD(namespaces);
1278 248 : COPY_NODE_FIELD(columns);
1279 248 : COPY_NODE_FIELD(alias);
1280 248 : COPY_LOCATION_FIELD(location);
1281 :
1282 248 : return newnode;
1283 : }
1284 :
1285 : static RangeTableFuncCol *
1286 918 : _copyRangeTableFuncCol(const RangeTableFuncCol *from)
1287 : {
1288 918 : RangeTableFuncCol *newnode = makeNode(RangeTableFuncCol);
1289 :
1290 918 : COPY_STRING_FIELD(colname);
1291 918 : COPY_NODE_FIELD(typeName);
1292 918 : COPY_SCALAR_FIELD(for_ordinality);
1293 918 : COPY_SCALAR_FIELD(is_not_null);
1294 918 : COPY_NODE_FIELD(colexpr);
1295 918 : COPY_NODE_FIELD(coldefexpr);
1296 918 : COPY_LOCATION_FIELD(location);
1297 :
1298 918 : return newnode;
1299 : }
1300 :
1301 : static RangeTableSample *
1302 274 : _copyRangeTableSample(const RangeTableSample *from)
1303 : {
1304 274 : RangeTableSample *newnode = makeNode(RangeTableSample);
1305 :
1306 274 : COPY_NODE_FIELD(relation);
1307 274 : COPY_NODE_FIELD(method);
1308 274 : COPY_NODE_FIELD(args);
1309 274 : COPY_NODE_FIELD(repeatable);
1310 274 : COPY_LOCATION_FIELD(location);
1311 :
1312 274 : return newnode;
1313 : }
1314 :
1315 : static ColumnDef *
1316 140850 : _copyColumnDef(const ColumnDef *from)
1317 : {
1318 140850 : ColumnDef *newnode = makeNode(ColumnDef);
1319 :
1320 140850 : COPY_STRING_FIELD(colname);
1321 140850 : COPY_NODE_FIELD(typeName);
1322 140850 : COPY_STRING_FIELD(compression);
1323 140850 : COPY_SCALAR_FIELD(inhcount);
1324 140850 : COPY_SCALAR_FIELD(is_local);
1325 140850 : COPY_SCALAR_FIELD(is_not_null);
1326 140850 : COPY_SCALAR_FIELD(is_from_type);
1327 140850 : COPY_SCALAR_FIELD(storage);
1328 140850 : COPY_STRING_FIELD(storage_name);
1329 140850 : COPY_NODE_FIELD(raw_default);
1330 140850 : COPY_NODE_FIELD(cooked_default);
1331 140850 : COPY_SCALAR_FIELD(identity);
1332 140850 : COPY_NODE_FIELD(identitySequence);
1333 140850 : COPY_SCALAR_FIELD(generated);
1334 140850 : COPY_NODE_FIELD(collClause);
1335 140850 : COPY_SCALAR_FIELD(collOid);
1336 140850 : COPY_NODE_FIELD(constraints);
1337 140850 : COPY_NODE_FIELD(fdwoptions);
1338 140850 : COPY_LOCATION_FIELD(location);
1339 :
1340 140850 : return newnode;
1341 : }
1342 :
1343 : static TableLikeClause *
1344 1500 : _copyTableLikeClause(const TableLikeClause *from)
1345 : {
1346 1500 : TableLikeClause *newnode = makeNode(TableLikeClause);
1347 :
1348 1500 : COPY_NODE_FIELD(relation);
1349 1500 : COPY_SCALAR_FIELD(options);
1350 1500 : COPY_SCALAR_FIELD(relationOid);
1351 :
1352 1500 : return newnode;
1353 : }
1354 :
1355 : static IndexElem *
1356 19640 : _copyIndexElem(const IndexElem *from)
1357 : {
1358 19640 : IndexElem *newnode = makeNode(IndexElem);
1359 :
1360 19640 : COPY_STRING_FIELD(name);
1361 19640 : COPY_NODE_FIELD(expr);
1362 19640 : COPY_STRING_FIELD(indexcolname);
1363 19640 : COPY_NODE_FIELD(collation);
1364 19640 : COPY_NODE_FIELD(opclass);
1365 19640 : COPY_NODE_FIELD(opclassopts);
1366 19640 : COPY_SCALAR_FIELD(ordering);
1367 19640 : COPY_SCALAR_FIELD(nulls_ordering);
1368 :
1369 19640 : return newnode;
1370 : }
1371 :
1372 : static DefElem *
1373 332774 : _copyDefElem(const DefElem *from)
1374 : {
1375 332774 : DefElem *newnode = makeNode(DefElem);
1376 :
1377 332774 : COPY_STRING_FIELD(defnamespace);
1378 332774 : COPY_STRING_FIELD(defname);
1379 332774 : COPY_NODE_FIELD(arg);
1380 332774 : COPY_SCALAR_FIELD(defaction);
1381 332774 : COPY_LOCATION_FIELD(location);
1382 :
1383 332774 : return newnode;
1384 : }
1385 :
1386 : static LockingClause *
1387 5336 : _copyLockingClause(const LockingClause *from)
1388 : {
1389 5336 : LockingClause *newnode = makeNode(LockingClause);
1390 :
1391 5336 : COPY_NODE_FIELD(lockedRels);
1392 5336 : COPY_SCALAR_FIELD(strength);
1393 5336 : COPY_SCALAR_FIELD(waitPolicy);
1394 :
1395 5336 : return newnode;
1396 : }
1397 :
1398 : static XmlSerialize *
1399 218 : _copyXmlSerialize(const XmlSerialize *from)
1400 : {
1401 218 : XmlSerialize *newnode = makeNode(XmlSerialize);
1402 :
1403 218 : COPY_SCALAR_FIELD(xmloption);
1404 218 : COPY_NODE_FIELD(expr);
1405 218 : COPY_NODE_FIELD(typeName);
1406 218 : COPY_SCALAR_FIELD(indent);
1407 218 : COPY_LOCATION_FIELD(location);
1408 :
1409 218 : return newnode;
1410 : }
1411 :
1412 : static PartitionElem *
1413 10876 : _copyPartitionElem(const PartitionElem *from)
1414 : {
1415 10876 : PartitionElem *newnode = makeNode(PartitionElem);
1416 :
1417 10876 : COPY_STRING_FIELD(name);
1418 10876 : COPY_NODE_FIELD(expr);
1419 10876 : COPY_NODE_FIELD(collation);
1420 10876 : COPY_NODE_FIELD(opclass);
1421 10876 : COPY_LOCATION_FIELD(location);
1422 :
1423 10876 : return newnode;
1424 : }
1425 :
1426 : static PartitionSpec *
1427 9702 : _copyPartitionSpec(const PartitionSpec *from)
1428 : {
1429 9702 : PartitionSpec *newnode = makeNode(PartitionSpec);
1430 :
1431 9702 : COPY_SCALAR_FIELD(strategy);
1432 9702 : COPY_NODE_FIELD(partParams);
1433 9702 : COPY_LOCATION_FIELD(location);
1434 :
1435 9702 : return newnode;
1436 : }
1437 :
1438 : static PartitionBoundSpec *
1439 32240 : _copyPartitionBoundSpec(const PartitionBoundSpec *from)
1440 : {
1441 32240 : PartitionBoundSpec *newnode = makeNode(PartitionBoundSpec);
1442 :
1443 32240 : COPY_SCALAR_FIELD(strategy);
1444 32240 : COPY_SCALAR_FIELD(is_default);
1445 32240 : COPY_SCALAR_FIELD(modulus);
1446 32240 : COPY_SCALAR_FIELD(remainder);
1447 32240 : COPY_NODE_FIELD(listdatums);
1448 32240 : COPY_NODE_FIELD(lowerdatums);
1449 32240 : COPY_NODE_FIELD(upperdatums);
1450 32240 : COPY_LOCATION_FIELD(location);
1451 :
1452 32240 : return newnode;
1453 : }
1454 :
1455 : static PartitionRangeDatum *
1456 4 : _copyPartitionRangeDatum(const PartitionRangeDatum *from)
1457 : {
1458 4 : PartitionRangeDatum *newnode = makeNode(PartitionRangeDatum);
1459 :
1460 4 : COPY_SCALAR_FIELD(kind);
1461 4 : COPY_NODE_FIELD(value);
1462 4 : COPY_LOCATION_FIELD(location);
1463 :
1464 4 : return newnode;
1465 : }
1466 :
1467 : static PartitionCmd *
1468 9686 : _copyPartitionCmd(const PartitionCmd *from)
1469 : {
1470 9686 : PartitionCmd *newnode = makeNode(PartitionCmd);
1471 :
1472 9686 : COPY_NODE_FIELD(name);
1473 9686 : COPY_NODE_FIELD(bound);
1474 9686 : COPY_SCALAR_FIELD(concurrent);
1475 :
1476 9686 : return newnode;
1477 : }
1478 :
1479 : static RangeTblEntry *
1480 1890774 : _copyRangeTblEntry(const RangeTblEntry *from)
1481 : {
1482 1890774 : RangeTblEntry *newnode = makeNode(RangeTblEntry);
1483 :
1484 1890774 : COPY_NODE_FIELD(alias);
1485 1890774 : COPY_NODE_FIELD(eref);
1486 1890774 : COPY_SCALAR_FIELD(rtekind);
1487 1890774 : COPY_SCALAR_FIELD(relid);
1488 1890774 : COPY_SCALAR_FIELD(inh);
1489 1890774 : COPY_SCALAR_FIELD(relkind);
1490 1890774 : COPY_SCALAR_FIELD(rellockmode);
1491 1890774 : COPY_SCALAR_FIELD(perminfoindex);
1492 1890774 : COPY_NODE_FIELD(tablesample);
1493 1890774 : COPY_NODE_FIELD(subquery);
1494 1890774 : COPY_SCALAR_FIELD(security_barrier);
1495 1890774 : COPY_SCALAR_FIELD(jointype);
1496 1890774 : COPY_SCALAR_FIELD(joinmergedcols);
1497 1890774 : COPY_NODE_FIELD(joinaliasvars);
1498 1890774 : COPY_NODE_FIELD(joinleftcols);
1499 1890774 : COPY_NODE_FIELD(joinrightcols);
1500 1890774 : COPY_NODE_FIELD(join_using_alias);
1501 1890774 : COPY_NODE_FIELD(functions);
1502 1890774 : COPY_SCALAR_FIELD(funcordinality);
1503 1890774 : COPY_NODE_FIELD(tablefunc);
1504 1890774 : COPY_NODE_FIELD(values_lists);
1505 1890774 : COPY_STRING_FIELD(ctename);
1506 1890774 : COPY_SCALAR_FIELD(ctelevelsup);
1507 1890774 : COPY_SCALAR_FIELD(self_reference);
1508 1890774 : COPY_NODE_FIELD(coltypes);
1509 1890774 : COPY_NODE_FIELD(coltypmods);
1510 1890774 : COPY_NODE_FIELD(colcollations);
1511 1890774 : COPY_STRING_FIELD(enrname);
1512 1890774 : COPY_SCALAR_FIELD(enrtuples);
1513 1890774 : COPY_NODE_FIELD(groupexprs);
1514 1890774 : COPY_SCALAR_FIELD(lateral);
1515 1890774 : COPY_SCALAR_FIELD(inFromCl);
1516 1890774 : COPY_NODE_FIELD(securityQuals);
1517 :
1518 1890774 : return newnode;
1519 : }
1520 :
1521 : static RTEPermissionInfo *
1522 1125986 : _copyRTEPermissionInfo(const RTEPermissionInfo *from)
1523 : {
1524 1125986 : RTEPermissionInfo *newnode = makeNode(RTEPermissionInfo);
1525 :
1526 1125986 : COPY_SCALAR_FIELD(relid);
1527 1125986 : COPY_SCALAR_FIELD(inh);
1528 1125986 : COPY_SCALAR_FIELD(requiredPerms);
1529 1125986 : COPY_SCALAR_FIELD(checkAsUser);
1530 1125986 : COPY_BITMAPSET_FIELD(selectedCols);
1531 1125986 : COPY_BITMAPSET_FIELD(insertedCols);
1532 1125986 : COPY_BITMAPSET_FIELD(updatedCols);
1533 :
1534 1125986 : return newnode;
1535 : }
1536 :
1537 : static RangeTblFunction *
1538 116164 : _copyRangeTblFunction(const RangeTblFunction *from)
1539 : {
1540 116164 : RangeTblFunction *newnode = makeNode(RangeTblFunction);
1541 :
1542 116164 : COPY_NODE_FIELD(funcexpr);
1543 116164 : COPY_SCALAR_FIELD(funccolcount);
1544 116164 : COPY_NODE_FIELD(funccolnames);
1545 116164 : COPY_NODE_FIELD(funccoltypes);
1546 116164 : COPY_NODE_FIELD(funccoltypmods);
1547 116164 : COPY_NODE_FIELD(funccolcollations);
1548 116164 : COPY_BITMAPSET_FIELD(funcparams);
1549 :
1550 116164 : return newnode;
1551 : }
1552 :
1553 : static TableSampleClause *
1554 720 : _copyTableSampleClause(const TableSampleClause *from)
1555 : {
1556 720 : TableSampleClause *newnode = makeNode(TableSampleClause);
1557 :
1558 720 : COPY_SCALAR_FIELD(tsmhandler);
1559 720 : COPY_NODE_FIELD(args);
1560 720 : COPY_NODE_FIELD(repeatable);
1561 :
1562 720 : return newnode;
1563 : }
1564 :
1565 : static WithCheckOption *
1566 4566 : _copyWithCheckOption(const WithCheckOption *from)
1567 : {
1568 4566 : WithCheckOption *newnode = makeNode(WithCheckOption);
1569 :
1570 4566 : COPY_SCALAR_FIELD(kind);
1571 4566 : COPY_STRING_FIELD(relname);
1572 4566 : COPY_STRING_FIELD(polname);
1573 4566 : COPY_NODE_FIELD(qual);
1574 4566 : COPY_SCALAR_FIELD(cascaded);
1575 :
1576 4566 : return newnode;
1577 : }
1578 :
1579 : static SortGroupClause *
1580 219302 : _copySortGroupClause(const SortGroupClause *from)
1581 : {
1582 219302 : SortGroupClause *newnode = makeNode(SortGroupClause);
1583 :
1584 219302 : COPY_SCALAR_FIELD(tleSortGroupRef);
1585 219302 : COPY_SCALAR_FIELD(eqop);
1586 219302 : COPY_SCALAR_FIELD(sortop);
1587 219302 : COPY_SCALAR_FIELD(reverse_sort);
1588 219302 : COPY_SCALAR_FIELD(nulls_first);
1589 219302 : COPY_SCALAR_FIELD(hashable);
1590 :
1591 219302 : return newnode;
1592 : }
1593 :
1594 : static GroupingSet *
1595 4336 : _copyGroupingSet(const GroupingSet *from)
1596 : {
1597 4336 : GroupingSet *newnode = makeNode(GroupingSet);
1598 :
1599 4336 : COPY_SCALAR_FIELD(kind);
1600 4336 : COPY_NODE_FIELD(content);
1601 4336 : COPY_LOCATION_FIELD(location);
1602 :
1603 4336 : return newnode;
1604 : }
1605 :
1606 : static WindowClause *
1607 3386 : _copyWindowClause(const WindowClause *from)
1608 : {
1609 3386 : WindowClause *newnode = makeNode(WindowClause);
1610 :
1611 3386 : COPY_STRING_FIELD(name);
1612 3386 : COPY_STRING_FIELD(refname);
1613 3386 : COPY_NODE_FIELD(partitionClause);
1614 3386 : COPY_NODE_FIELD(orderClause);
1615 3386 : COPY_SCALAR_FIELD(frameOptions);
1616 3386 : COPY_NODE_FIELD(startOffset);
1617 3386 : COPY_NODE_FIELD(endOffset);
1618 3386 : COPY_SCALAR_FIELD(startInRangeFunc);
1619 3386 : COPY_SCALAR_FIELD(endInRangeFunc);
1620 3386 : COPY_SCALAR_FIELD(inRangeColl);
1621 3386 : COPY_SCALAR_FIELD(inRangeAsc);
1622 3386 : COPY_SCALAR_FIELD(inRangeNullsFirst);
1623 3386 : COPY_SCALAR_FIELD(winref);
1624 3386 : COPY_SCALAR_FIELD(copiedOrder);
1625 :
1626 3386 : return newnode;
1627 : }
1628 :
1629 : static RowMarkClause *
1630 15368 : _copyRowMarkClause(const RowMarkClause *from)
1631 : {
1632 15368 : RowMarkClause *newnode = makeNode(RowMarkClause);
1633 :
1634 15368 : COPY_SCALAR_FIELD(rti);
1635 15368 : COPY_SCALAR_FIELD(strength);
1636 15368 : COPY_SCALAR_FIELD(waitPolicy);
1637 15368 : COPY_SCALAR_FIELD(pushedDown);
1638 :
1639 15368 : return newnode;
1640 : }
1641 :
1642 : static WithClause *
1643 3010 : _copyWithClause(const WithClause *from)
1644 : {
1645 3010 : WithClause *newnode = makeNode(WithClause);
1646 :
1647 3010 : COPY_NODE_FIELD(ctes);
1648 3010 : COPY_SCALAR_FIELD(recursive);
1649 3010 : COPY_LOCATION_FIELD(location);
1650 :
1651 3010 : return newnode;
1652 : }
1653 :
1654 : static InferClause *
1655 1622 : _copyInferClause(const InferClause *from)
1656 : {
1657 1622 : InferClause *newnode = makeNode(InferClause);
1658 :
1659 1622 : COPY_NODE_FIELD(indexElems);
1660 1622 : COPY_NODE_FIELD(whereClause);
1661 1622 : COPY_STRING_FIELD(conname);
1662 1622 : COPY_LOCATION_FIELD(location);
1663 :
1664 1622 : return newnode;
1665 : }
1666 :
1667 : static OnConflictClause *
1668 1868 : _copyOnConflictClause(const OnConflictClause *from)
1669 : {
1670 1868 : OnConflictClause *newnode = makeNode(OnConflictClause);
1671 :
1672 1868 : COPY_SCALAR_FIELD(action);
1673 1868 : COPY_NODE_FIELD(infer);
1674 1868 : COPY_NODE_FIELD(targetList);
1675 1868 : COPY_NODE_FIELD(whereClause);
1676 1868 : COPY_LOCATION_FIELD(location);
1677 :
1678 1868 : return newnode;
1679 : }
1680 :
1681 : static CTESearchClause *
1682 306 : _copyCTESearchClause(const CTESearchClause *from)
1683 : {
1684 306 : CTESearchClause *newnode = makeNode(CTESearchClause);
1685 :
1686 306 : COPY_NODE_FIELD(search_col_list);
1687 306 : COPY_SCALAR_FIELD(search_breadth_first);
1688 306 : COPY_STRING_FIELD(search_seq_column);
1689 306 : COPY_LOCATION_FIELD(location);
1690 :
1691 306 : return newnode;
1692 : }
1693 :
1694 : static CTECycleClause *
1695 306 : _copyCTECycleClause(const CTECycleClause *from)
1696 : {
1697 306 : CTECycleClause *newnode = makeNode(CTECycleClause);
1698 :
1699 306 : COPY_NODE_FIELD(cycle_col_list);
1700 306 : COPY_STRING_FIELD(cycle_mark_column);
1701 306 : COPY_NODE_FIELD(cycle_mark_value);
1702 306 : COPY_NODE_FIELD(cycle_mark_default);
1703 306 : COPY_STRING_FIELD(cycle_path_column);
1704 306 : COPY_LOCATION_FIELD(location);
1705 306 : COPY_SCALAR_FIELD(cycle_mark_type);
1706 306 : COPY_SCALAR_FIELD(cycle_mark_typmod);
1707 306 : COPY_SCALAR_FIELD(cycle_mark_collation);
1708 306 : COPY_SCALAR_FIELD(cycle_mark_neop);
1709 :
1710 306 : return newnode;
1711 : }
1712 :
1713 : static CommonTableExpr *
1714 8922 : _copyCommonTableExpr(const CommonTableExpr *from)
1715 : {
1716 8922 : CommonTableExpr *newnode = makeNode(CommonTableExpr);
1717 :
1718 8922 : COPY_STRING_FIELD(ctename);
1719 8922 : COPY_NODE_FIELD(aliascolnames);
1720 8922 : COPY_SCALAR_FIELD(ctematerialized);
1721 8922 : COPY_NODE_FIELD(ctequery);
1722 8922 : COPY_NODE_FIELD(search_clause);
1723 8922 : COPY_NODE_FIELD(cycle_clause);
1724 8922 : COPY_LOCATION_FIELD(location);
1725 8922 : COPY_SCALAR_FIELD(cterecursive);
1726 8922 : COPY_SCALAR_FIELD(cterefcount);
1727 8922 : COPY_NODE_FIELD(ctecolnames);
1728 8922 : COPY_NODE_FIELD(ctecoltypes);
1729 8922 : COPY_NODE_FIELD(ctecoltypmods);
1730 8922 : COPY_NODE_FIELD(ctecolcollations);
1731 :
1732 8922 : return newnode;
1733 : }
1734 :
1735 : static MergeWhenClause *
1736 3122 : _copyMergeWhenClause(const MergeWhenClause *from)
1737 : {
1738 3122 : MergeWhenClause *newnode = makeNode(MergeWhenClause);
1739 :
1740 3122 : COPY_SCALAR_FIELD(matchKind);
1741 3122 : COPY_SCALAR_FIELD(commandType);
1742 3122 : COPY_SCALAR_FIELD(override);
1743 3122 : COPY_NODE_FIELD(condition);
1744 3122 : COPY_NODE_FIELD(targetList);
1745 3122 : COPY_NODE_FIELD(values);
1746 :
1747 3122 : return newnode;
1748 : }
1749 :
1750 : static TriggerTransition *
1751 1124 : _copyTriggerTransition(const TriggerTransition *from)
1752 : {
1753 1124 : TriggerTransition *newnode = makeNode(TriggerTransition);
1754 :
1755 1124 : COPY_STRING_FIELD(name);
1756 1124 : COPY_SCALAR_FIELD(isNew);
1757 1124 : COPY_SCALAR_FIELD(isTable);
1758 :
1759 1124 : return newnode;
1760 : }
1761 :
1762 : static JsonOutput *
1763 1546 : _copyJsonOutput(const JsonOutput *from)
1764 : {
1765 1546 : JsonOutput *newnode = makeNode(JsonOutput);
1766 :
1767 1546 : COPY_NODE_FIELD(typeName);
1768 1546 : COPY_NODE_FIELD(returning);
1769 :
1770 1546 : return newnode;
1771 : }
1772 :
1773 : static JsonArgument *
1774 612 : _copyJsonArgument(const JsonArgument *from)
1775 : {
1776 612 : JsonArgument *newnode = makeNode(JsonArgument);
1777 :
1778 612 : COPY_NODE_FIELD(val);
1779 612 : COPY_STRING_FIELD(name);
1780 :
1781 612 : return newnode;
1782 : }
1783 :
1784 : static JsonFuncExpr *
1785 1974 : _copyJsonFuncExpr(const JsonFuncExpr *from)
1786 : {
1787 1974 : JsonFuncExpr *newnode = makeNode(JsonFuncExpr);
1788 :
1789 1974 : COPY_SCALAR_FIELD(op);
1790 1974 : COPY_STRING_FIELD(column_name);
1791 1974 : COPY_NODE_FIELD(context_item);
1792 1974 : COPY_NODE_FIELD(pathspec);
1793 1974 : COPY_NODE_FIELD(passing);
1794 1974 : COPY_NODE_FIELD(output);
1795 1974 : COPY_NODE_FIELD(on_empty);
1796 1974 : COPY_NODE_FIELD(on_error);
1797 1974 : COPY_SCALAR_FIELD(wrapper);
1798 1974 : COPY_SCALAR_FIELD(quotes);
1799 1974 : COPY_LOCATION_FIELD(location);
1800 :
1801 1974 : return newnode;
1802 : }
1803 :
1804 : static JsonTablePathSpec *
1805 1972 : _copyJsonTablePathSpec(const JsonTablePathSpec *from)
1806 : {
1807 1972 : JsonTablePathSpec *newnode = makeNode(JsonTablePathSpec);
1808 :
1809 1972 : COPY_NODE_FIELD(string);
1810 1972 : COPY_STRING_FIELD(name);
1811 1972 : COPY_LOCATION_FIELD(name_location);
1812 1972 : COPY_LOCATION_FIELD(location);
1813 :
1814 1972 : return newnode;
1815 : }
1816 :
1817 : static JsonTable *
1818 590 : _copyJsonTable(const JsonTable *from)
1819 : {
1820 590 : JsonTable *newnode = makeNode(JsonTable);
1821 :
1822 590 : COPY_NODE_FIELD(context_item);
1823 590 : COPY_NODE_FIELD(pathspec);
1824 590 : COPY_NODE_FIELD(passing);
1825 590 : COPY_NODE_FIELD(columns);
1826 590 : COPY_NODE_FIELD(on_error);
1827 590 : COPY_NODE_FIELD(alias);
1828 590 : COPY_SCALAR_FIELD(lateral);
1829 590 : COPY_LOCATION_FIELD(location);
1830 :
1831 590 : return newnode;
1832 : }
1833 :
1834 : static JsonTableColumn *
1835 1648 : _copyJsonTableColumn(const JsonTableColumn *from)
1836 : {
1837 1648 : JsonTableColumn *newnode = makeNode(JsonTableColumn);
1838 :
1839 1648 : COPY_SCALAR_FIELD(coltype);
1840 1648 : COPY_STRING_FIELD(name);
1841 1648 : COPY_NODE_FIELD(typeName);
1842 1648 : COPY_NODE_FIELD(pathspec);
1843 1648 : COPY_NODE_FIELD(format);
1844 1648 : COPY_SCALAR_FIELD(wrapper);
1845 1648 : COPY_SCALAR_FIELD(quotes);
1846 1648 : COPY_NODE_FIELD(columns);
1847 1648 : COPY_NODE_FIELD(on_empty);
1848 1648 : COPY_NODE_FIELD(on_error);
1849 1648 : COPY_LOCATION_FIELD(location);
1850 :
1851 1648 : return newnode;
1852 : }
1853 :
1854 : static JsonKeyValue *
1855 868 : _copyJsonKeyValue(const JsonKeyValue *from)
1856 : {
1857 868 : JsonKeyValue *newnode = makeNode(JsonKeyValue);
1858 :
1859 868 : COPY_NODE_FIELD(key);
1860 868 : COPY_NODE_FIELD(value);
1861 :
1862 868 : return newnode;
1863 : }
1864 :
1865 : static JsonParseExpr *
1866 164 : _copyJsonParseExpr(const JsonParseExpr *from)
1867 : {
1868 164 : JsonParseExpr *newnode = makeNode(JsonParseExpr);
1869 :
1870 164 : COPY_NODE_FIELD(expr);
1871 164 : COPY_NODE_FIELD(output);
1872 164 : COPY_SCALAR_FIELD(unique_keys);
1873 164 : COPY_LOCATION_FIELD(location);
1874 :
1875 164 : return newnode;
1876 : }
1877 :
1878 : static JsonScalarExpr *
1879 112 : _copyJsonScalarExpr(const JsonScalarExpr *from)
1880 : {
1881 112 : JsonScalarExpr *newnode = makeNode(JsonScalarExpr);
1882 :
1883 112 : COPY_NODE_FIELD(expr);
1884 112 : COPY_NODE_FIELD(output);
1885 112 : COPY_LOCATION_FIELD(location);
1886 :
1887 112 : return newnode;
1888 : }
1889 :
1890 : static JsonSerializeExpr *
1891 108 : _copyJsonSerializeExpr(const JsonSerializeExpr *from)
1892 : {
1893 108 : JsonSerializeExpr *newnode = makeNode(JsonSerializeExpr);
1894 :
1895 108 : COPY_NODE_FIELD(expr);
1896 108 : COPY_NODE_FIELD(output);
1897 108 : COPY_LOCATION_FIELD(location);
1898 :
1899 108 : return newnode;
1900 : }
1901 :
1902 : static JsonObjectConstructor *
1903 452 : _copyJsonObjectConstructor(const JsonObjectConstructor *from)
1904 : {
1905 452 : JsonObjectConstructor *newnode = makeNode(JsonObjectConstructor);
1906 :
1907 452 : COPY_NODE_FIELD(exprs);
1908 452 : COPY_NODE_FIELD(output);
1909 452 : COPY_SCALAR_FIELD(absent_on_null);
1910 452 : COPY_SCALAR_FIELD(unique);
1911 452 : COPY_LOCATION_FIELD(location);
1912 :
1913 452 : return newnode;
1914 : }
1915 :
1916 : static JsonArrayConstructor *
1917 212 : _copyJsonArrayConstructor(const JsonArrayConstructor *from)
1918 : {
1919 212 : JsonArrayConstructor *newnode = makeNode(JsonArrayConstructor);
1920 :
1921 212 : COPY_NODE_FIELD(exprs);
1922 212 : COPY_NODE_FIELD(output);
1923 212 : COPY_SCALAR_FIELD(absent_on_null);
1924 212 : COPY_LOCATION_FIELD(location);
1925 :
1926 212 : return newnode;
1927 : }
1928 :
1929 : static JsonArrayQueryConstructor *
1930 60 : _copyJsonArrayQueryConstructor(const JsonArrayQueryConstructor *from)
1931 : {
1932 60 : JsonArrayQueryConstructor *newnode = makeNode(JsonArrayQueryConstructor);
1933 :
1934 60 : COPY_NODE_FIELD(query);
1935 60 : COPY_NODE_FIELD(output);
1936 60 : COPY_NODE_FIELD(format);
1937 60 : COPY_SCALAR_FIELD(absent_on_null);
1938 60 : COPY_LOCATION_FIELD(location);
1939 :
1940 60 : return newnode;
1941 : }
1942 :
1943 : static JsonAggConstructor *
1944 408 : _copyJsonAggConstructor(const JsonAggConstructor *from)
1945 : {
1946 408 : JsonAggConstructor *newnode = makeNode(JsonAggConstructor);
1947 :
1948 408 : COPY_NODE_FIELD(output);
1949 408 : COPY_NODE_FIELD(agg_filter);
1950 408 : COPY_NODE_FIELD(agg_order);
1951 408 : COPY_NODE_FIELD(over);
1952 408 : COPY_LOCATION_FIELD(location);
1953 :
1954 408 : return newnode;
1955 : }
1956 :
1957 : static JsonObjectAgg *
1958 246 : _copyJsonObjectAgg(const JsonObjectAgg *from)
1959 : {
1960 246 : JsonObjectAgg *newnode = makeNode(JsonObjectAgg);
1961 :
1962 246 : COPY_NODE_FIELD(constructor);
1963 246 : COPY_NODE_FIELD(arg);
1964 246 : COPY_SCALAR_FIELD(absent_on_null);
1965 246 : COPY_SCALAR_FIELD(unique);
1966 :
1967 246 : return newnode;
1968 : }
1969 :
1970 : static JsonArrayAgg *
1971 162 : _copyJsonArrayAgg(const JsonArrayAgg *from)
1972 : {
1973 162 : JsonArrayAgg *newnode = makeNode(JsonArrayAgg);
1974 :
1975 162 : COPY_NODE_FIELD(constructor);
1976 162 : COPY_NODE_FIELD(arg);
1977 162 : COPY_SCALAR_FIELD(absent_on_null);
1978 :
1979 162 : return newnode;
1980 : }
1981 :
1982 : static RawStmt *
1983 775884 : _copyRawStmt(const RawStmt *from)
1984 : {
1985 775884 : RawStmt *newnode = makeNode(RawStmt);
1986 :
1987 775884 : COPY_NODE_FIELD(stmt);
1988 775884 : COPY_LOCATION_FIELD(stmt_location);
1989 775884 : COPY_LOCATION_FIELD(stmt_len);
1990 :
1991 775884 : return newnode;
1992 : }
1993 :
1994 : static InsertStmt *
1995 78300 : _copyInsertStmt(const InsertStmt *from)
1996 : {
1997 78300 : InsertStmt *newnode = makeNode(InsertStmt);
1998 :
1999 78300 : COPY_NODE_FIELD(relation);
2000 78300 : COPY_NODE_FIELD(cols);
2001 78300 : COPY_NODE_FIELD(selectStmt);
2002 78300 : COPY_NODE_FIELD(onConflictClause);
2003 78300 : COPY_NODE_FIELD(returningList);
2004 78300 : COPY_NODE_FIELD(withClause);
2005 78300 : COPY_SCALAR_FIELD(override);
2006 78300 : COPY_LOCATION_FIELD(stmt_location);
2007 78300 : COPY_LOCATION_FIELD(stmt_len);
2008 :
2009 78300 : return newnode;
2010 : }
2011 :
2012 : static DeleteStmt *
2013 4684 : _copyDeleteStmt(const DeleteStmt *from)
2014 : {
2015 4684 : DeleteStmt *newnode = makeNode(DeleteStmt);
2016 :
2017 4684 : COPY_NODE_FIELD(relation);
2018 4684 : COPY_NODE_FIELD(usingClause);
2019 4684 : COPY_NODE_FIELD(whereClause);
2020 4684 : COPY_NODE_FIELD(returningList);
2021 4684 : COPY_NODE_FIELD(withClause);
2022 4684 : COPY_LOCATION_FIELD(stmt_location);
2023 4684 : COPY_LOCATION_FIELD(stmt_len);
2024 :
2025 4684 : return newnode;
2026 : }
2027 :
2028 : static UpdateStmt *
2029 13556 : _copyUpdateStmt(const UpdateStmt *from)
2030 : {
2031 13556 : UpdateStmt *newnode = makeNode(UpdateStmt);
2032 :
2033 13556 : COPY_NODE_FIELD(relation);
2034 13556 : COPY_NODE_FIELD(targetList);
2035 13556 : COPY_NODE_FIELD(whereClause);
2036 13556 : COPY_NODE_FIELD(fromClause);
2037 13556 : COPY_NODE_FIELD(returningList);
2038 13556 : COPY_NODE_FIELD(withClause);
2039 13556 : COPY_LOCATION_FIELD(stmt_location);
2040 13556 : COPY_LOCATION_FIELD(stmt_len);
2041 :
2042 13556 : return newnode;
2043 : }
2044 :
2045 : static MergeStmt *
2046 1972 : _copyMergeStmt(const MergeStmt *from)
2047 : {
2048 1972 : MergeStmt *newnode = makeNode(MergeStmt);
2049 :
2050 1972 : COPY_NODE_FIELD(relation);
2051 1972 : COPY_NODE_FIELD(sourceRelation);
2052 1972 : COPY_NODE_FIELD(joinCondition);
2053 1972 : COPY_NODE_FIELD(mergeWhenClauses);
2054 1972 : COPY_NODE_FIELD(returningList);
2055 1972 : COPY_NODE_FIELD(withClause);
2056 1972 : COPY_LOCATION_FIELD(stmt_location);
2057 1972 : COPY_LOCATION_FIELD(stmt_len);
2058 :
2059 1972 : return newnode;
2060 : }
2061 :
2062 : static SelectStmt *
2063 569050 : _copySelectStmt(const SelectStmt *from)
2064 : {
2065 569050 : SelectStmt *newnode = makeNode(SelectStmt);
2066 :
2067 569050 : COPY_NODE_FIELD(distinctClause);
2068 569050 : COPY_NODE_FIELD(intoClause);
2069 569050 : COPY_NODE_FIELD(targetList);
2070 569050 : COPY_NODE_FIELD(fromClause);
2071 569050 : COPY_NODE_FIELD(whereClause);
2072 569050 : COPY_NODE_FIELD(groupClause);
2073 569050 : COPY_SCALAR_FIELD(groupDistinct);
2074 569050 : COPY_NODE_FIELD(havingClause);
2075 569050 : COPY_NODE_FIELD(windowClause);
2076 569050 : COPY_NODE_FIELD(valuesLists);
2077 569050 : COPY_NODE_FIELD(sortClause);
2078 569050 : COPY_NODE_FIELD(limitOffset);
2079 569050 : COPY_NODE_FIELD(limitCount);
2080 569050 : COPY_SCALAR_FIELD(limitOption);
2081 569050 : COPY_NODE_FIELD(lockingClause);
2082 569050 : COPY_NODE_FIELD(withClause);
2083 569050 : COPY_SCALAR_FIELD(op);
2084 569050 : COPY_SCALAR_FIELD(all);
2085 569050 : COPY_NODE_FIELD(larg);
2086 569050 : COPY_NODE_FIELD(rarg);
2087 569050 : COPY_LOCATION_FIELD(stmt_location);
2088 569050 : COPY_LOCATION_FIELD(stmt_len);
2089 :
2090 569050 : return newnode;
2091 : }
2092 :
2093 : static SetOperationStmt *
2094 15694 : _copySetOperationStmt(const SetOperationStmt *from)
2095 : {
2096 15694 : SetOperationStmt *newnode = makeNode(SetOperationStmt);
2097 :
2098 15694 : COPY_SCALAR_FIELD(op);
2099 15694 : COPY_SCALAR_FIELD(all);
2100 15694 : COPY_NODE_FIELD(larg);
2101 15694 : COPY_NODE_FIELD(rarg);
2102 15694 : COPY_NODE_FIELD(colTypes);
2103 15694 : COPY_NODE_FIELD(colTypmods);
2104 15694 : COPY_NODE_FIELD(colCollations);
2105 15694 : COPY_NODE_FIELD(groupClauses);
2106 :
2107 15694 : return newnode;
2108 : }
2109 :
2110 : static ReturnStmt *
2111 8620 : _copyReturnStmt(const ReturnStmt *from)
2112 : {
2113 8620 : ReturnStmt *newnode = makeNode(ReturnStmt);
2114 :
2115 8620 : COPY_NODE_FIELD(returnval);
2116 :
2117 8620 : return newnode;
2118 : }
2119 :
2120 : static PLAssignStmt *
2121 5106 : _copyPLAssignStmt(const PLAssignStmt *from)
2122 : {
2123 5106 : PLAssignStmt *newnode = makeNode(PLAssignStmt);
2124 :
2125 5106 : COPY_STRING_FIELD(name);
2126 5106 : COPY_NODE_FIELD(indirection);
2127 5106 : COPY_SCALAR_FIELD(nnames);
2128 5106 : COPY_NODE_FIELD(val);
2129 5106 : COPY_LOCATION_FIELD(location);
2130 :
2131 5106 : return newnode;
2132 : }
2133 :
2134 : static CreateSchemaStmt *
2135 2062 : _copyCreateSchemaStmt(const CreateSchemaStmt *from)
2136 : {
2137 2062 : CreateSchemaStmt *newnode = makeNode(CreateSchemaStmt);
2138 :
2139 2062 : COPY_STRING_FIELD(schemaname);
2140 2062 : COPY_NODE_FIELD(authrole);
2141 2062 : COPY_NODE_FIELD(schemaElts);
2142 2062 : COPY_SCALAR_FIELD(if_not_exists);
2143 :
2144 2062 : return newnode;
2145 : }
2146 :
2147 : static AlterTableStmt *
2148 55824 : _copyAlterTableStmt(const AlterTableStmt *from)
2149 : {
2150 55824 : AlterTableStmt *newnode = makeNode(AlterTableStmt);
2151 :
2152 55824 : COPY_NODE_FIELD(relation);
2153 55824 : COPY_NODE_FIELD(cmds);
2154 55824 : COPY_SCALAR_FIELD(objtype);
2155 55824 : COPY_SCALAR_FIELD(missing_ok);
2156 :
2157 55824 : return newnode;
2158 : }
2159 :
2160 : static ReplicaIdentityStmt *
2161 1326 : _copyReplicaIdentityStmt(const ReplicaIdentityStmt *from)
2162 : {
2163 1326 : ReplicaIdentityStmt *newnode = makeNode(ReplicaIdentityStmt);
2164 :
2165 1326 : COPY_SCALAR_FIELD(identity_type);
2166 1326 : COPY_STRING_FIELD(name);
2167 :
2168 1326 : return newnode;
2169 : }
2170 :
2171 : static AlterTableCmd *
2172 92738 : _copyAlterTableCmd(const AlterTableCmd *from)
2173 : {
2174 92738 : AlterTableCmd *newnode = makeNode(AlterTableCmd);
2175 :
2176 92738 : COPY_SCALAR_FIELD(subtype);
2177 92738 : COPY_STRING_FIELD(name);
2178 92738 : COPY_SCALAR_FIELD(num);
2179 92738 : COPY_NODE_FIELD(newowner);
2180 92738 : COPY_NODE_FIELD(def);
2181 92738 : COPY_SCALAR_FIELD(behavior);
2182 92738 : COPY_SCALAR_FIELD(missing_ok);
2183 92738 : COPY_SCALAR_FIELD(recurse);
2184 :
2185 92738 : return newnode;
2186 : }
2187 :
2188 : static AlterCollationStmt *
2189 12 : _copyAlterCollationStmt(const AlterCollationStmt *from)
2190 : {
2191 12 : AlterCollationStmt *newnode = makeNode(AlterCollationStmt);
2192 :
2193 12 : COPY_NODE_FIELD(collname);
2194 :
2195 12 : return newnode;
2196 : }
2197 :
2198 : static AlterDomainStmt *
2199 544 : _copyAlterDomainStmt(const AlterDomainStmt *from)
2200 : {
2201 544 : AlterDomainStmt *newnode = makeNode(AlterDomainStmt);
2202 :
2203 544 : COPY_SCALAR_FIELD(subtype);
2204 544 : COPY_NODE_FIELD(typeName);
2205 544 : COPY_STRING_FIELD(name);
2206 544 : COPY_NODE_FIELD(def);
2207 544 : COPY_SCALAR_FIELD(behavior);
2208 544 : COPY_SCALAR_FIELD(missing_ok);
2209 :
2210 544 : return newnode;
2211 : }
2212 :
2213 : static GrantStmt *
2214 46124 : _copyGrantStmt(const GrantStmt *from)
2215 : {
2216 46124 : GrantStmt *newnode = makeNode(GrantStmt);
2217 :
2218 46124 : COPY_SCALAR_FIELD(is_grant);
2219 46124 : COPY_SCALAR_FIELD(targtype);
2220 46124 : COPY_SCALAR_FIELD(objtype);
2221 46124 : COPY_NODE_FIELD(objects);
2222 46124 : COPY_NODE_FIELD(privileges);
2223 46124 : COPY_NODE_FIELD(grantees);
2224 46124 : COPY_SCALAR_FIELD(grant_option);
2225 46124 : COPY_NODE_FIELD(grantor);
2226 46124 : COPY_SCALAR_FIELD(behavior);
2227 :
2228 46124 : return newnode;
2229 : }
2230 :
2231 : static ObjectWithArgs *
2232 35910 : _copyObjectWithArgs(const ObjectWithArgs *from)
2233 : {
2234 35910 : ObjectWithArgs *newnode = makeNode(ObjectWithArgs);
2235 :
2236 35910 : COPY_NODE_FIELD(objname);
2237 35910 : COPY_NODE_FIELD(objargs);
2238 35910 : COPY_NODE_FIELD(objfuncargs);
2239 35910 : COPY_SCALAR_FIELD(args_unspecified);
2240 :
2241 35910 : return newnode;
2242 : }
2243 :
2244 : static AccessPriv *
2245 44420 : _copyAccessPriv(const AccessPriv *from)
2246 : {
2247 44420 : AccessPriv *newnode = makeNode(AccessPriv);
2248 :
2249 44420 : COPY_STRING_FIELD(priv_name);
2250 44420 : COPY_NODE_FIELD(cols);
2251 :
2252 44420 : return newnode;
2253 : }
2254 :
2255 : static GrantRoleStmt *
2256 1886 : _copyGrantRoleStmt(const GrantRoleStmt *from)
2257 : {
2258 1886 : GrantRoleStmt *newnode = makeNode(GrantRoleStmt);
2259 :
2260 1886 : COPY_NODE_FIELD(granted_roles);
2261 1886 : COPY_NODE_FIELD(grantee_roles);
2262 1886 : COPY_SCALAR_FIELD(is_grant);
2263 1886 : COPY_NODE_FIELD(opt);
2264 1886 : COPY_NODE_FIELD(grantor);
2265 1886 : COPY_SCALAR_FIELD(behavior);
2266 :
2267 1886 : return newnode;
2268 : }
2269 :
2270 : static AlterDefaultPrivilegesStmt *
2271 328 : _copyAlterDefaultPrivilegesStmt(const AlterDefaultPrivilegesStmt *from)
2272 : {
2273 328 : AlterDefaultPrivilegesStmt *newnode = makeNode(AlterDefaultPrivilegesStmt);
2274 :
2275 328 : COPY_NODE_FIELD(options);
2276 328 : COPY_NODE_FIELD(action);
2277 :
2278 328 : return newnode;
2279 : }
2280 :
2281 : static CopyStmt *
2282 19698 : _copyCopyStmt(const CopyStmt *from)
2283 : {
2284 19698 : CopyStmt *newnode = makeNode(CopyStmt);
2285 :
2286 19698 : COPY_NODE_FIELD(relation);
2287 19698 : COPY_NODE_FIELD(query);
2288 19698 : COPY_NODE_FIELD(attlist);
2289 19698 : COPY_SCALAR_FIELD(is_from);
2290 19698 : COPY_SCALAR_FIELD(is_program);
2291 19698 : COPY_STRING_FIELD(filename);
2292 19698 : COPY_NODE_FIELD(options);
2293 19698 : COPY_NODE_FIELD(whereClause);
2294 :
2295 19698 : return newnode;
2296 : }
2297 :
2298 : static VariableSetStmt *
2299 62398 : _copyVariableSetStmt(const VariableSetStmt *from)
2300 : {
2301 62398 : VariableSetStmt *newnode = makeNode(VariableSetStmt);
2302 :
2303 62398 : COPY_SCALAR_FIELD(kind);
2304 62398 : COPY_STRING_FIELD(name);
2305 62398 : COPY_NODE_FIELD(args);
2306 62398 : COPY_SCALAR_FIELD(jumble_args);
2307 62398 : COPY_SCALAR_FIELD(is_local);
2308 62398 : COPY_LOCATION_FIELD(location);
2309 :
2310 62398 : return newnode;
2311 : }
2312 :
2313 : static VariableShowStmt *
2314 1700 : _copyVariableShowStmt(const VariableShowStmt *from)
2315 : {
2316 1700 : VariableShowStmt *newnode = makeNode(VariableShowStmt);
2317 :
2318 1700 : COPY_STRING_FIELD(name);
2319 :
2320 1700 : return newnode;
2321 : }
2322 :
2323 : static CreateStmt *
2324 71016 : _copyCreateStmt(const CreateStmt *from)
2325 : {
2326 71016 : CreateStmt *newnode = makeNode(CreateStmt);
2327 :
2328 71016 : COPY_NODE_FIELD(relation);
2329 71016 : COPY_NODE_FIELD(tableElts);
2330 71016 : COPY_NODE_FIELD(inhRelations);
2331 71016 : COPY_NODE_FIELD(partbound);
2332 71016 : COPY_NODE_FIELD(partspec);
2333 71016 : COPY_NODE_FIELD(ofTypename);
2334 71016 : COPY_NODE_FIELD(constraints);
2335 71016 : COPY_NODE_FIELD(nnconstraints);
2336 71016 : COPY_NODE_FIELD(options);
2337 71016 : COPY_SCALAR_FIELD(oncommit);
2338 71016 : COPY_STRING_FIELD(tablespacename);
2339 71016 : COPY_STRING_FIELD(accessMethod);
2340 71016 : COPY_SCALAR_FIELD(if_not_exists);
2341 :
2342 71016 : return newnode;
2343 : }
2344 :
2345 : static Constraint *
2346 91342 : _copyConstraint(const Constraint *from)
2347 : {
2348 91342 : Constraint *newnode = makeNode(Constraint);
2349 :
2350 91342 : COPY_SCALAR_FIELD(contype);
2351 91342 : COPY_STRING_FIELD(conname);
2352 91342 : COPY_SCALAR_FIELD(deferrable);
2353 91342 : COPY_SCALAR_FIELD(initdeferred);
2354 91342 : COPY_SCALAR_FIELD(skip_validation);
2355 91342 : COPY_SCALAR_FIELD(initially_valid);
2356 91342 : COPY_SCALAR_FIELD(is_no_inherit);
2357 91342 : COPY_NODE_FIELD(raw_expr);
2358 91342 : COPY_STRING_FIELD(cooked_expr);
2359 91342 : COPY_SCALAR_FIELD(generated_when);
2360 91342 : COPY_SCALAR_FIELD(nulls_not_distinct);
2361 91342 : COPY_NODE_FIELD(keys);
2362 91342 : COPY_SCALAR_FIELD(without_overlaps);
2363 91342 : COPY_NODE_FIELD(including);
2364 91342 : COPY_NODE_FIELD(exclusions);
2365 91342 : COPY_NODE_FIELD(options);
2366 91342 : COPY_STRING_FIELD(indexname);
2367 91342 : COPY_STRING_FIELD(indexspace);
2368 91342 : COPY_SCALAR_FIELD(reset_default_tblspc);
2369 91342 : COPY_STRING_FIELD(access_method);
2370 91342 : COPY_NODE_FIELD(where_clause);
2371 91342 : COPY_NODE_FIELD(pktable);
2372 91342 : COPY_NODE_FIELD(fk_attrs);
2373 91342 : COPY_NODE_FIELD(pk_attrs);
2374 91342 : COPY_SCALAR_FIELD(fk_with_period);
2375 91342 : COPY_SCALAR_FIELD(pk_with_period);
2376 91342 : COPY_SCALAR_FIELD(fk_matchtype);
2377 91342 : COPY_SCALAR_FIELD(fk_upd_action);
2378 91342 : COPY_SCALAR_FIELD(fk_del_action);
2379 91342 : COPY_NODE_FIELD(fk_del_set_cols);
2380 91342 : COPY_NODE_FIELD(old_conpfeqop);
2381 91342 : COPY_SCALAR_FIELD(old_pktable_oid);
2382 91342 : COPY_LOCATION_FIELD(location);
2383 :
2384 91342 : return newnode;
2385 : }
2386 :
2387 : static CreateTableSpaceStmt *
2388 224 : _copyCreateTableSpaceStmt(const CreateTableSpaceStmt *from)
2389 : {
2390 224 : CreateTableSpaceStmt *newnode = makeNode(CreateTableSpaceStmt);
2391 :
2392 224 : COPY_STRING_FIELD(tablespacename);
2393 224 : COPY_NODE_FIELD(owner);
2394 224 : COPY_STRING_FIELD(location);
2395 224 : COPY_NODE_FIELD(options);
2396 :
2397 224 : return newnode;
2398 : }
2399 :
2400 : static DropTableSpaceStmt *
2401 128 : _copyDropTableSpaceStmt(const DropTableSpaceStmt *from)
2402 : {
2403 128 : DropTableSpaceStmt *newnode = makeNode(DropTableSpaceStmt);
2404 :
2405 128 : COPY_STRING_FIELD(tablespacename);
2406 128 : COPY_SCALAR_FIELD(missing_ok);
2407 :
2408 128 : return newnode;
2409 : }
2410 :
2411 : static AlterTableSpaceOptionsStmt *
2412 48 : _copyAlterTableSpaceOptionsStmt(const AlterTableSpaceOptionsStmt *from)
2413 : {
2414 48 : AlterTableSpaceOptionsStmt *newnode = makeNode(AlterTableSpaceOptionsStmt);
2415 :
2416 48 : COPY_STRING_FIELD(tablespacename);
2417 48 : COPY_NODE_FIELD(options);
2418 48 : COPY_SCALAR_FIELD(isReset);
2419 :
2420 48 : return newnode;
2421 : }
2422 :
2423 : static AlterTableMoveAllStmt *
2424 120 : _copyAlterTableMoveAllStmt(const AlterTableMoveAllStmt *from)
2425 : {
2426 120 : AlterTableMoveAllStmt *newnode = makeNode(AlterTableMoveAllStmt);
2427 :
2428 120 : COPY_STRING_FIELD(orig_tablespacename);
2429 120 : COPY_SCALAR_FIELD(objtype);
2430 120 : COPY_NODE_FIELD(roles);
2431 120 : COPY_STRING_FIELD(new_tablespacename);
2432 120 : COPY_SCALAR_FIELD(nowait);
2433 :
2434 120 : return newnode;
2435 : }
2436 :
2437 : static CreateExtensionStmt *
2438 950 : _copyCreateExtensionStmt(const CreateExtensionStmt *from)
2439 : {
2440 950 : CreateExtensionStmt *newnode = makeNode(CreateExtensionStmt);
2441 :
2442 950 : COPY_STRING_FIELD(extname);
2443 950 : COPY_SCALAR_FIELD(if_not_exists);
2444 950 : COPY_NODE_FIELD(options);
2445 :
2446 950 : return newnode;
2447 : }
2448 :
2449 : static AlterExtensionStmt *
2450 74 : _copyAlterExtensionStmt(const AlterExtensionStmt *from)
2451 : {
2452 74 : AlterExtensionStmt *newnode = makeNode(AlterExtensionStmt);
2453 :
2454 74 : COPY_STRING_FIELD(extname);
2455 74 : COPY_NODE_FIELD(options);
2456 :
2457 74 : return newnode;
2458 : }
2459 :
2460 : static AlterExtensionContentsStmt *
2461 462 : _copyAlterExtensionContentsStmt(const AlterExtensionContentsStmt *from)
2462 : {
2463 462 : AlterExtensionContentsStmt *newnode = makeNode(AlterExtensionContentsStmt);
2464 :
2465 462 : COPY_STRING_FIELD(extname);
2466 462 : COPY_SCALAR_FIELD(action);
2467 462 : COPY_SCALAR_FIELD(objtype);
2468 462 : COPY_NODE_FIELD(object);
2469 :
2470 462 : return newnode;
2471 : }
2472 :
2473 : static CreateFdwStmt *
2474 388 : _copyCreateFdwStmt(const CreateFdwStmt *from)
2475 : {
2476 388 : CreateFdwStmt *newnode = makeNode(CreateFdwStmt);
2477 :
2478 388 : COPY_STRING_FIELD(fdwname);
2479 388 : COPY_NODE_FIELD(func_options);
2480 388 : COPY_NODE_FIELD(options);
2481 :
2482 388 : return newnode;
2483 : }
2484 :
2485 : static AlterFdwStmt *
2486 244 : _copyAlterFdwStmt(const AlterFdwStmt *from)
2487 : {
2488 244 : AlterFdwStmt *newnode = makeNode(AlterFdwStmt);
2489 :
2490 244 : COPY_STRING_FIELD(fdwname);
2491 244 : COPY_NODE_FIELD(func_options);
2492 244 : COPY_NODE_FIELD(options);
2493 :
2494 244 : return newnode;
2495 : }
2496 :
2497 : static CreateForeignServerStmt *
2498 552 : _copyCreateForeignServerStmt(const CreateForeignServerStmt *from)
2499 : {
2500 552 : CreateForeignServerStmt *newnode = makeNode(CreateForeignServerStmt);
2501 :
2502 552 : COPY_STRING_FIELD(servername);
2503 552 : COPY_STRING_FIELD(servertype);
2504 552 : COPY_STRING_FIELD(version);
2505 552 : COPY_STRING_FIELD(fdwname);
2506 552 : COPY_SCALAR_FIELD(if_not_exists);
2507 552 : COPY_NODE_FIELD(options);
2508 :
2509 552 : return newnode;
2510 : }
2511 :
2512 : static AlterForeignServerStmt *
2513 440 : _copyAlterForeignServerStmt(const AlterForeignServerStmt *from)
2514 : {
2515 440 : AlterForeignServerStmt *newnode = makeNode(AlterForeignServerStmt);
2516 :
2517 440 : COPY_STRING_FIELD(servername);
2518 440 : COPY_STRING_FIELD(version);
2519 440 : COPY_NODE_FIELD(options);
2520 440 : COPY_SCALAR_FIELD(has_version);
2521 :
2522 440 : return newnode;
2523 : }
2524 :
2525 : static CreateForeignTableStmt *
2526 846 : _copyCreateForeignTableStmt(const CreateForeignTableStmt *from)
2527 : {
2528 846 : CreateForeignTableStmt *newnode = makeNode(CreateForeignTableStmt);
2529 :
2530 846 : COPY_NODE_FIELD(base.relation);
2531 846 : COPY_NODE_FIELD(base.tableElts);
2532 846 : COPY_NODE_FIELD(base.inhRelations);
2533 846 : COPY_NODE_FIELD(base.partbound);
2534 846 : COPY_NODE_FIELD(base.partspec);
2535 846 : COPY_NODE_FIELD(base.ofTypename);
2536 846 : COPY_NODE_FIELD(base.constraints);
2537 846 : COPY_NODE_FIELD(base.nnconstraints);
2538 846 : COPY_NODE_FIELD(base.options);
2539 846 : COPY_SCALAR_FIELD(base.oncommit);
2540 846 : COPY_STRING_FIELD(base.tablespacename);
2541 846 : COPY_STRING_FIELD(base.accessMethod);
2542 846 : COPY_SCALAR_FIELD(base.if_not_exists);
2543 846 : COPY_STRING_FIELD(servername);
2544 846 : COPY_NODE_FIELD(options);
2545 :
2546 846 : return newnode;
2547 : }
2548 :
2549 : static CreateUserMappingStmt *
2550 482 : _copyCreateUserMappingStmt(const CreateUserMappingStmt *from)
2551 : {
2552 482 : CreateUserMappingStmt *newnode = makeNode(CreateUserMappingStmt);
2553 :
2554 482 : COPY_NODE_FIELD(user);
2555 482 : COPY_STRING_FIELD(servername);
2556 482 : COPY_SCALAR_FIELD(if_not_exists);
2557 482 : COPY_NODE_FIELD(options);
2558 :
2559 482 : return newnode;
2560 : }
2561 :
2562 : static AlterUserMappingStmt *
2563 220 : _copyAlterUserMappingStmt(const AlterUserMappingStmt *from)
2564 : {
2565 220 : AlterUserMappingStmt *newnode = makeNode(AlterUserMappingStmt);
2566 :
2567 220 : COPY_NODE_FIELD(user);
2568 220 : COPY_STRING_FIELD(servername);
2569 220 : COPY_NODE_FIELD(options);
2570 :
2571 220 : return newnode;
2572 : }
2573 :
2574 : static DropUserMappingStmt *
2575 252 : _copyDropUserMappingStmt(const DropUserMappingStmt *from)
2576 : {
2577 252 : DropUserMappingStmt *newnode = makeNode(DropUserMappingStmt);
2578 :
2579 252 : COPY_NODE_FIELD(user);
2580 252 : COPY_STRING_FIELD(servername);
2581 252 : COPY_SCALAR_FIELD(missing_ok);
2582 :
2583 252 : return newnode;
2584 : }
2585 :
2586 : static ImportForeignSchemaStmt *
2587 88 : _copyImportForeignSchemaStmt(const ImportForeignSchemaStmt *from)
2588 : {
2589 88 : ImportForeignSchemaStmt *newnode = makeNode(ImportForeignSchemaStmt);
2590 :
2591 88 : COPY_STRING_FIELD(server_name);
2592 88 : COPY_STRING_FIELD(remote_schema);
2593 88 : COPY_STRING_FIELD(local_schema);
2594 88 : COPY_SCALAR_FIELD(list_type);
2595 88 : COPY_NODE_FIELD(table_list);
2596 88 : COPY_NODE_FIELD(options);
2597 :
2598 88 : return newnode;
2599 : }
2600 :
2601 : static CreatePolicyStmt *
2602 1334 : _copyCreatePolicyStmt(const CreatePolicyStmt *from)
2603 : {
2604 1334 : CreatePolicyStmt *newnode = makeNode(CreatePolicyStmt);
2605 :
2606 1334 : COPY_STRING_FIELD(policy_name);
2607 1334 : COPY_NODE_FIELD(table);
2608 1334 : COPY_STRING_FIELD(cmd_name);
2609 1334 : COPY_SCALAR_FIELD(permissive);
2610 1334 : COPY_NODE_FIELD(roles);
2611 1334 : COPY_NODE_FIELD(qual);
2612 1334 : COPY_NODE_FIELD(with_check);
2613 :
2614 1334 : return newnode;
2615 : }
2616 :
2617 : static AlterPolicyStmt *
2618 174 : _copyAlterPolicyStmt(const AlterPolicyStmt *from)
2619 : {
2620 174 : AlterPolicyStmt *newnode = makeNode(AlterPolicyStmt);
2621 :
2622 174 : COPY_STRING_FIELD(policy_name);
2623 174 : COPY_NODE_FIELD(table);
2624 174 : COPY_NODE_FIELD(roles);
2625 174 : COPY_NODE_FIELD(qual);
2626 174 : COPY_NODE_FIELD(with_check);
2627 :
2628 174 : return newnode;
2629 : }
2630 :
2631 : static CreateAmStmt *
2632 124 : _copyCreateAmStmt(const CreateAmStmt *from)
2633 : {
2634 124 : CreateAmStmt *newnode = makeNode(CreateAmStmt);
2635 :
2636 124 : COPY_STRING_FIELD(amname);
2637 124 : COPY_NODE_FIELD(handler_name);
2638 124 : COPY_SCALAR_FIELD(amtype);
2639 :
2640 124 : return newnode;
2641 : }
2642 :
2643 : static CreateTrigStmt *
2644 6922 : _copyCreateTrigStmt(const CreateTrigStmt *from)
2645 : {
2646 6922 : CreateTrigStmt *newnode = makeNode(CreateTrigStmt);
2647 :
2648 6922 : COPY_SCALAR_FIELD(replace);
2649 6922 : COPY_SCALAR_FIELD(isconstraint);
2650 6922 : COPY_STRING_FIELD(trigname);
2651 6922 : COPY_NODE_FIELD(relation);
2652 6922 : COPY_NODE_FIELD(funcname);
2653 6922 : COPY_NODE_FIELD(args);
2654 6922 : COPY_SCALAR_FIELD(row);
2655 6922 : COPY_SCALAR_FIELD(timing);
2656 6922 : COPY_SCALAR_FIELD(events);
2657 6922 : COPY_NODE_FIELD(columns);
2658 6922 : COPY_NODE_FIELD(whenClause);
2659 6922 : COPY_NODE_FIELD(transitionRels);
2660 6922 : COPY_SCALAR_FIELD(deferrable);
2661 6922 : COPY_SCALAR_FIELD(initdeferred);
2662 6922 : COPY_NODE_FIELD(constrrel);
2663 :
2664 6922 : return newnode;
2665 : }
2666 :
2667 : static CreateEventTrigStmt *
2668 392 : _copyCreateEventTrigStmt(const CreateEventTrigStmt *from)
2669 : {
2670 392 : CreateEventTrigStmt *newnode = makeNode(CreateEventTrigStmt);
2671 :
2672 392 : COPY_STRING_FIELD(trigname);
2673 392 : COPY_STRING_FIELD(eventname);
2674 392 : COPY_NODE_FIELD(whenclause);
2675 392 : COPY_NODE_FIELD(funcname);
2676 :
2677 392 : return newnode;
2678 : }
2679 :
2680 : static AlterEventTrigStmt *
2681 96 : _copyAlterEventTrigStmt(const AlterEventTrigStmt *from)
2682 : {
2683 96 : AlterEventTrigStmt *newnode = makeNode(AlterEventTrigStmt);
2684 :
2685 96 : COPY_STRING_FIELD(trigname);
2686 96 : COPY_SCALAR_FIELD(tgenabled);
2687 :
2688 96 : return newnode;
2689 : }
2690 :
2691 : static CreatePLangStmt *
2692 264 : _copyCreatePLangStmt(const CreatePLangStmt *from)
2693 : {
2694 264 : CreatePLangStmt *newnode = makeNode(CreatePLangStmt);
2695 :
2696 264 : COPY_SCALAR_FIELD(replace);
2697 264 : COPY_STRING_FIELD(plname);
2698 264 : COPY_NODE_FIELD(plhandler);
2699 264 : COPY_NODE_FIELD(plinline);
2700 264 : COPY_NODE_FIELD(plvalidator);
2701 264 : COPY_SCALAR_FIELD(pltrusted);
2702 :
2703 264 : return newnode;
2704 : }
2705 :
2706 : static CreateRoleStmt *
2707 3504 : _copyCreateRoleStmt(const CreateRoleStmt *from)
2708 : {
2709 3504 : CreateRoleStmt *newnode = makeNode(CreateRoleStmt);
2710 :
2711 3504 : COPY_SCALAR_FIELD(stmt_type);
2712 3504 : COPY_STRING_FIELD(role);
2713 3504 : COPY_NODE_FIELD(options);
2714 :
2715 3504 : return newnode;
2716 : }
2717 :
2718 : static AlterRoleStmt *
2719 860 : _copyAlterRoleStmt(const AlterRoleStmt *from)
2720 : {
2721 860 : AlterRoleStmt *newnode = makeNode(AlterRoleStmt);
2722 :
2723 860 : COPY_NODE_FIELD(role);
2724 860 : COPY_NODE_FIELD(options);
2725 860 : COPY_SCALAR_FIELD(action);
2726 :
2727 860 : return newnode;
2728 : }
2729 :
2730 : static AlterRoleSetStmt *
2731 164 : _copyAlterRoleSetStmt(const AlterRoleSetStmt *from)
2732 : {
2733 164 : AlterRoleSetStmt *newnode = makeNode(AlterRoleSetStmt);
2734 :
2735 164 : COPY_NODE_FIELD(role);
2736 164 : COPY_STRING_FIELD(database);
2737 164 : COPY_NODE_FIELD(setstmt);
2738 :
2739 164 : return newnode;
2740 : }
2741 :
2742 : static DropRoleStmt *
2743 3344 : _copyDropRoleStmt(const DropRoleStmt *from)
2744 : {
2745 3344 : DropRoleStmt *newnode = makeNode(DropRoleStmt);
2746 :
2747 3344 : COPY_NODE_FIELD(roles);
2748 3344 : COPY_SCALAR_FIELD(missing_ok);
2749 :
2750 3344 : return newnode;
2751 : }
2752 :
2753 : static CreateSeqStmt *
2754 1382 : _copyCreateSeqStmt(const CreateSeqStmt *from)
2755 : {
2756 1382 : CreateSeqStmt *newnode = makeNode(CreateSeqStmt);
2757 :
2758 1382 : COPY_NODE_FIELD(sequence);
2759 1382 : COPY_NODE_FIELD(options);
2760 1382 : COPY_SCALAR_FIELD(ownerId);
2761 1382 : COPY_SCALAR_FIELD(for_identity);
2762 1382 : COPY_SCALAR_FIELD(if_not_exists);
2763 :
2764 1382 : return newnode;
2765 : }
2766 :
2767 : static AlterSeqStmt *
2768 476 : _copyAlterSeqStmt(const AlterSeqStmt *from)
2769 : {
2770 476 : AlterSeqStmt *newnode = makeNode(AlterSeqStmt);
2771 :
2772 476 : COPY_NODE_FIELD(sequence);
2773 476 : COPY_NODE_FIELD(options);
2774 476 : COPY_SCALAR_FIELD(for_identity);
2775 476 : COPY_SCALAR_FIELD(missing_ok);
2776 :
2777 476 : return newnode;
2778 : }
2779 :
2780 : static DefineStmt *
2781 16860 : _copyDefineStmt(const DefineStmt *from)
2782 : {
2783 16860 : DefineStmt *newnode = makeNode(DefineStmt);
2784 :
2785 16860 : COPY_SCALAR_FIELD(kind);
2786 16860 : COPY_SCALAR_FIELD(oldstyle);
2787 16860 : COPY_NODE_FIELD(defnames);
2788 16860 : COPY_NODE_FIELD(args);
2789 16860 : COPY_NODE_FIELD(definition);
2790 16860 : COPY_SCALAR_FIELD(if_not_exists);
2791 16860 : COPY_SCALAR_FIELD(replace);
2792 :
2793 16860 : return newnode;
2794 : }
2795 :
2796 : static CreateDomainStmt *
2797 2494 : _copyCreateDomainStmt(const CreateDomainStmt *from)
2798 : {
2799 2494 : CreateDomainStmt *newnode = makeNode(CreateDomainStmt);
2800 :
2801 2494 : COPY_NODE_FIELD(domainname);
2802 2494 : COPY_NODE_FIELD(typeName);
2803 2494 : COPY_NODE_FIELD(collClause);
2804 2494 : COPY_NODE_FIELD(constraints);
2805 :
2806 2494 : return newnode;
2807 : }
2808 :
2809 : static CreateOpClassStmt *
2810 784 : _copyCreateOpClassStmt(const CreateOpClassStmt *from)
2811 : {
2812 784 : CreateOpClassStmt *newnode = makeNode(CreateOpClassStmt);
2813 :
2814 784 : COPY_NODE_FIELD(opclassname);
2815 784 : COPY_NODE_FIELD(opfamilyname);
2816 784 : COPY_STRING_FIELD(amname);
2817 784 : COPY_NODE_FIELD(datatype);
2818 784 : COPY_NODE_FIELD(items);
2819 784 : COPY_SCALAR_FIELD(isDefault);
2820 :
2821 784 : return newnode;
2822 : }
2823 :
2824 : static CreateOpClassItem *
2825 8050 : _copyCreateOpClassItem(const CreateOpClassItem *from)
2826 : {
2827 8050 : CreateOpClassItem *newnode = makeNode(CreateOpClassItem);
2828 :
2829 8050 : COPY_SCALAR_FIELD(itemtype);
2830 8050 : COPY_NODE_FIELD(name);
2831 8050 : COPY_SCALAR_FIELD(number);
2832 8050 : COPY_NODE_FIELD(order_family);
2833 8050 : COPY_NODE_FIELD(class_args);
2834 8050 : COPY_NODE_FIELD(storedtype);
2835 :
2836 8050 : return newnode;
2837 : }
2838 :
2839 : static CreateOpFamilyStmt *
2840 304 : _copyCreateOpFamilyStmt(const CreateOpFamilyStmt *from)
2841 : {
2842 304 : CreateOpFamilyStmt *newnode = makeNode(CreateOpFamilyStmt);
2843 :
2844 304 : COPY_NODE_FIELD(opfamilyname);
2845 304 : COPY_STRING_FIELD(amname);
2846 :
2847 304 : return newnode;
2848 : }
2849 :
2850 : static AlterOpFamilyStmt *
2851 1030 : _copyAlterOpFamilyStmt(const AlterOpFamilyStmt *from)
2852 : {
2853 1030 : AlterOpFamilyStmt *newnode = makeNode(AlterOpFamilyStmt);
2854 :
2855 1030 : COPY_NODE_FIELD(opfamilyname);
2856 1030 : COPY_STRING_FIELD(amname);
2857 1030 : COPY_SCALAR_FIELD(isDrop);
2858 1030 : COPY_NODE_FIELD(items);
2859 :
2860 1030 : return newnode;
2861 : }
2862 :
2863 : static DropStmt *
2864 49084 : _copyDropStmt(const DropStmt *from)
2865 : {
2866 49084 : DropStmt *newnode = makeNode(DropStmt);
2867 :
2868 49084 : COPY_NODE_FIELD(objects);
2869 49084 : COPY_SCALAR_FIELD(removeType);
2870 49084 : COPY_SCALAR_FIELD(behavior);
2871 49084 : COPY_SCALAR_FIELD(missing_ok);
2872 49084 : COPY_SCALAR_FIELD(concurrent);
2873 :
2874 49084 : return newnode;
2875 : }
2876 :
2877 : static TruncateStmt *
2878 3224 : _copyTruncateStmt(const TruncateStmt *from)
2879 : {
2880 3224 : TruncateStmt *newnode = makeNode(TruncateStmt);
2881 :
2882 3224 : COPY_NODE_FIELD(relations);
2883 3224 : COPY_SCALAR_FIELD(restart_seqs);
2884 3224 : COPY_SCALAR_FIELD(behavior);
2885 :
2886 3224 : return newnode;
2887 : }
2888 :
2889 : static CommentStmt *
2890 12344 : _copyCommentStmt(const CommentStmt *from)
2891 : {
2892 12344 : CommentStmt *newnode = makeNode(CommentStmt);
2893 :
2894 12344 : COPY_SCALAR_FIELD(objtype);
2895 12344 : COPY_NODE_FIELD(object);
2896 12344 : COPY_STRING_FIELD(comment);
2897 :
2898 12344 : return newnode;
2899 : }
2900 :
2901 : static SecLabelStmt *
2902 202 : _copySecLabelStmt(const SecLabelStmt *from)
2903 : {
2904 202 : SecLabelStmt *newnode = makeNode(SecLabelStmt);
2905 :
2906 202 : COPY_SCALAR_FIELD(objtype);
2907 202 : COPY_NODE_FIELD(object);
2908 202 : COPY_STRING_FIELD(provider);
2909 202 : COPY_STRING_FIELD(label);
2910 :
2911 202 : return newnode;
2912 : }
2913 :
2914 : static DeclareCursorStmt *
2915 12264 : _copyDeclareCursorStmt(const DeclareCursorStmt *from)
2916 : {
2917 12264 : DeclareCursorStmt *newnode = makeNode(DeclareCursorStmt);
2918 :
2919 12264 : COPY_STRING_FIELD(portalname);
2920 12264 : COPY_SCALAR_FIELD(options);
2921 12264 : COPY_NODE_FIELD(query);
2922 :
2923 12264 : return newnode;
2924 : }
2925 :
2926 : static ClosePortalStmt *
2927 4368 : _copyClosePortalStmt(const ClosePortalStmt *from)
2928 : {
2929 4368 : ClosePortalStmt *newnode = makeNode(ClosePortalStmt);
2930 :
2931 4368 : COPY_STRING_FIELD(portalname);
2932 :
2933 4368 : return newnode;
2934 : }
2935 :
2936 : static FetchStmt *
2937 11484 : _copyFetchStmt(const FetchStmt *from)
2938 : {
2939 11484 : FetchStmt *newnode = makeNode(FetchStmt);
2940 :
2941 11484 : COPY_SCALAR_FIELD(direction);
2942 11484 : COPY_SCALAR_FIELD(howMany);
2943 11484 : COPY_STRING_FIELD(portalname);
2944 11484 : COPY_SCALAR_FIELD(ismove);
2945 :
2946 11484 : return newnode;
2947 : }
2948 :
2949 : static IndexStmt *
2950 13040 : _copyIndexStmt(const IndexStmt *from)
2951 : {
2952 13040 : IndexStmt *newnode = makeNode(IndexStmt);
2953 :
2954 13040 : COPY_STRING_FIELD(idxname);
2955 13040 : COPY_NODE_FIELD(relation);
2956 13040 : COPY_STRING_FIELD(accessMethod);
2957 13040 : COPY_STRING_FIELD(tableSpace);
2958 13040 : COPY_NODE_FIELD(indexParams);
2959 13040 : COPY_NODE_FIELD(indexIncludingParams);
2960 13040 : COPY_NODE_FIELD(options);
2961 13040 : COPY_NODE_FIELD(whereClause);
2962 13040 : COPY_NODE_FIELD(excludeOpNames);
2963 13040 : COPY_STRING_FIELD(idxcomment);
2964 13040 : COPY_SCALAR_FIELD(indexOid);
2965 13040 : COPY_SCALAR_FIELD(oldNumber);
2966 13040 : COPY_SCALAR_FIELD(oldCreateSubid);
2967 13040 : COPY_SCALAR_FIELD(oldFirstRelfilelocatorSubid);
2968 13040 : COPY_SCALAR_FIELD(unique);
2969 13040 : COPY_SCALAR_FIELD(nulls_not_distinct);
2970 13040 : COPY_SCALAR_FIELD(primary);
2971 13040 : COPY_SCALAR_FIELD(isconstraint);
2972 13040 : COPY_SCALAR_FIELD(iswithoutoverlaps);
2973 13040 : COPY_SCALAR_FIELD(deferrable);
2974 13040 : COPY_SCALAR_FIELD(initdeferred);
2975 13040 : COPY_SCALAR_FIELD(transformed);
2976 13040 : COPY_SCALAR_FIELD(concurrent);
2977 13040 : COPY_SCALAR_FIELD(if_not_exists);
2978 13040 : COPY_SCALAR_FIELD(reset_default_tblspc);
2979 :
2980 13040 : return newnode;
2981 : }
2982 :
2983 : static CreateStatsStmt *
2984 1132 : _copyCreateStatsStmt(const CreateStatsStmt *from)
2985 : {
2986 1132 : CreateStatsStmt *newnode = makeNode(CreateStatsStmt);
2987 :
2988 1132 : COPY_NODE_FIELD(defnames);
2989 1132 : COPY_NODE_FIELD(stat_types);
2990 1132 : COPY_NODE_FIELD(exprs);
2991 1132 : COPY_NODE_FIELD(relations);
2992 1132 : COPY_STRING_FIELD(stxcomment);
2993 1132 : COPY_SCALAR_FIELD(transformed);
2994 1132 : COPY_SCALAR_FIELD(if_not_exists);
2995 :
2996 1132 : return newnode;
2997 : }
2998 :
2999 : static StatsElem *
3000 2928 : _copyStatsElem(const StatsElem *from)
3001 : {
3002 2928 : StatsElem *newnode = makeNode(StatsElem);
3003 :
3004 2928 : COPY_STRING_FIELD(name);
3005 2928 : COPY_NODE_FIELD(expr);
3006 :
3007 2928 : return newnode;
3008 : }
3009 :
3010 : static AlterStatsStmt *
3011 52 : _copyAlterStatsStmt(const AlterStatsStmt *from)
3012 : {
3013 52 : AlterStatsStmt *newnode = makeNode(AlterStatsStmt);
3014 :
3015 52 : COPY_NODE_FIELD(defnames);
3016 52 : COPY_NODE_FIELD(stxstattarget);
3017 52 : COPY_SCALAR_FIELD(missing_ok);
3018 :
3019 52 : return newnode;
3020 : }
3021 :
3022 : static CreateFunctionStmt *
3023 44656 : _copyCreateFunctionStmt(const CreateFunctionStmt *from)
3024 : {
3025 44656 : CreateFunctionStmt *newnode = makeNode(CreateFunctionStmt);
3026 :
3027 44656 : COPY_SCALAR_FIELD(is_procedure);
3028 44656 : COPY_SCALAR_FIELD(replace);
3029 44656 : COPY_NODE_FIELD(funcname);
3030 44656 : COPY_NODE_FIELD(parameters);
3031 44656 : COPY_NODE_FIELD(returnType);
3032 44656 : COPY_NODE_FIELD(options);
3033 44656 : COPY_NODE_FIELD(sql_body);
3034 :
3035 44656 : return newnode;
3036 : }
3037 :
3038 : static FunctionParameter *
3039 136064 : _copyFunctionParameter(const FunctionParameter *from)
3040 : {
3041 136064 : FunctionParameter *newnode = makeNode(FunctionParameter);
3042 :
3043 136064 : COPY_STRING_FIELD(name);
3044 136064 : COPY_NODE_FIELD(argType);
3045 136064 : COPY_SCALAR_FIELD(mode);
3046 136064 : COPY_NODE_FIELD(defexpr);
3047 136064 : COPY_LOCATION_FIELD(location);
3048 :
3049 136064 : return newnode;
3050 : }
3051 :
3052 : static AlterFunctionStmt *
3053 1270 : _copyAlterFunctionStmt(const AlterFunctionStmt *from)
3054 : {
3055 1270 : AlterFunctionStmt *newnode = makeNode(AlterFunctionStmt);
3056 :
3057 1270 : COPY_SCALAR_FIELD(objtype);
3058 1270 : COPY_NODE_FIELD(func);
3059 1270 : COPY_NODE_FIELD(actions);
3060 :
3061 1270 : return newnode;
3062 : }
3063 :
3064 : static DoStmt *
3065 2662 : _copyDoStmt(const DoStmt *from)
3066 : {
3067 2662 : DoStmt *newnode = makeNode(DoStmt);
3068 :
3069 2662 : COPY_NODE_FIELD(args);
3070 :
3071 2662 : return newnode;
3072 : }
3073 :
3074 : static CallStmt *
3075 1592 : _copyCallStmt(const CallStmt *from)
3076 : {
3077 1592 : CallStmt *newnode = makeNode(CallStmt);
3078 :
3079 1592 : COPY_NODE_FIELD(funccall);
3080 1592 : COPY_NODE_FIELD(funcexpr);
3081 1592 : COPY_NODE_FIELD(outargs);
3082 :
3083 1592 : return newnode;
3084 : }
3085 :
3086 : static RenameStmt *
3087 3034 : _copyRenameStmt(const RenameStmt *from)
3088 : {
3089 3034 : RenameStmt *newnode = makeNode(RenameStmt);
3090 :
3091 3034 : COPY_SCALAR_FIELD(renameType);
3092 3034 : COPY_SCALAR_FIELD(relationType);
3093 3034 : COPY_NODE_FIELD(relation);
3094 3034 : COPY_NODE_FIELD(object);
3095 3034 : COPY_STRING_FIELD(subname);
3096 3034 : COPY_STRING_FIELD(newname);
3097 3034 : COPY_SCALAR_FIELD(behavior);
3098 3034 : COPY_SCALAR_FIELD(missing_ok);
3099 :
3100 3034 : return newnode;
3101 : }
3102 :
3103 : static AlterObjectDependsStmt *
3104 92 : _copyAlterObjectDependsStmt(const AlterObjectDependsStmt *from)
3105 : {
3106 92 : AlterObjectDependsStmt *newnode = makeNode(AlterObjectDependsStmt);
3107 :
3108 92 : COPY_SCALAR_FIELD(objectType);
3109 92 : COPY_NODE_FIELD(relation);
3110 92 : COPY_NODE_FIELD(object);
3111 92 : COPY_NODE_FIELD(extname);
3112 92 : COPY_SCALAR_FIELD(remove);
3113 :
3114 92 : return newnode;
3115 : }
3116 :
3117 : static AlterObjectSchemaStmt *
3118 800 : _copyAlterObjectSchemaStmt(const AlterObjectSchemaStmt *from)
3119 : {
3120 800 : AlterObjectSchemaStmt *newnode = makeNode(AlterObjectSchemaStmt);
3121 :
3122 800 : COPY_SCALAR_FIELD(objectType);
3123 800 : COPY_NODE_FIELD(relation);
3124 800 : COPY_NODE_FIELD(object);
3125 800 : COPY_STRING_FIELD(newschema);
3126 800 : COPY_SCALAR_FIELD(missing_ok);
3127 :
3128 800 : return newnode;
3129 : }
3130 :
3131 : static AlterOwnerStmt *
3132 3124 : _copyAlterOwnerStmt(const AlterOwnerStmt *from)
3133 : {
3134 3124 : AlterOwnerStmt *newnode = makeNode(AlterOwnerStmt);
3135 :
3136 3124 : COPY_SCALAR_FIELD(objectType);
3137 3124 : COPY_NODE_FIELD(relation);
3138 3124 : COPY_NODE_FIELD(object);
3139 3124 : COPY_NODE_FIELD(newowner);
3140 :
3141 3124 : return newnode;
3142 : }
3143 :
3144 : static AlterOperatorStmt *
3145 1216 : _copyAlterOperatorStmt(const AlterOperatorStmt *from)
3146 : {
3147 1216 : AlterOperatorStmt *newnode = makeNode(AlterOperatorStmt);
3148 :
3149 1216 : COPY_NODE_FIELD(opername);
3150 1216 : COPY_NODE_FIELD(options);
3151 :
3152 1216 : return newnode;
3153 : }
3154 :
3155 : static AlterTypeStmt *
3156 120 : _copyAlterTypeStmt(const AlterTypeStmt *from)
3157 : {
3158 120 : AlterTypeStmt *newnode = makeNode(AlterTypeStmt);
3159 :
3160 120 : COPY_NODE_FIELD(typeName);
3161 120 : COPY_NODE_FIELD(options);
3162 :
3163 120 : return newnode;
3164 : }
3165 :
3166 : static RuleStmt *
3167 2116 : _copyRuleStmt(const RuleStmt *from)
3168 : {
3169 2116 : RuleStmt *newnode = makeNode(RuleStmt);
3170 :
3171 2116 : COPY_NODE_FIELD(relation);
3172 2116 : COPY_STRING_FIELD(rulename);
3173 2116 : COPY_NODE_FIELD(whereClause);
3174 2116 : COPY_SCALAR_FIELD(event);
3175 2116 : COPY_SCALAR_FIELD(instead);
3176 2116 : COPY_NODE_FIELD(actions);
3177 2116 : COPY_SCALAR_FIELD(replace);
3178 :
3179 2116 : return newnode;
3180 : }
3181 :
3182 : static NotifyStmt *
3183 292 : _copyNotifyStmt(const NotifyStmt *from)
3184 : {
3185 292 : NotifyStmt *newnode = makeNode(NotifyStmt);
3186 :
3187 292 : COPY_STRING_FIELD(conditionname);
3188 292 : COPY_STRING_FIELD(payload);
3189 :
3190 292 : return newnode;
3191 : }
3192 :
3193 : static ListenStmt *
3194 148 : _copyListenStmt(const ListenStmt *from)
3195 : {
3196 148 : ListenStmt *newnode = makeNode(ListenStmt);
3197 :
3198 148 : COPY_STRING_FIELD(conditionname);
3199 :
3200 148 : return newnode;
3201 : }
3202 :
3203 : static UnlistenStmt *
3204 76 : _copyUnlistenStmt(const UnlistenStmt *from)
3205 : {
3206 76 : UnlistenStmt *newnode = makeNode(UnlistenStmt);
3207 :
3208 76 : COPY_STRING_FIELD(conditionname);
3209 :
3210 76 : return newnode;
3211 : }
3212 :
3213 : static TransactionStmt *
3214 71904 : _copyTransactionStmt(const TransactionStmt *from)
3215 : {
3216 71904 : TransactionStmt *newnode = makeNode(TransactionStmt);
3217 :
3218 71904 : COPY_SCALAR_FIELD(kind);
3219 71904 : COPY_NODE_FIELD(options);
3220 71904 : COPY_STRING_FIELD(savepoint_name);
3221 71904 : COPY_STRING_FIELD(gid);
3222 71904 : COPY_SCALAR_FIELD(chain);
3223 71904 : COPY_LOCATION_FIELD(location);
3224 :
3225 71904 : return newnode;
3226 : }
3227 :
3228 : static CompositeTypeStmt *
3229 6984 : _copyCompositeTypeStmt(const CompositeTypeStmt *from)
3230 : {
3231 6984 : CompositeTypeStmt *newnode = makeNode(CompositeTypeStmt);
3232 :
3233 6984 : COPY_NODE_FIELD(typevar);
3234 6984 : COPY_NODE_FIELD(coldeflist);
3235 :
3236 6984 : return newnode;
3237 : }
3238 :
3239 : static CreateEnumStmt *
3240 676 : _copyCreateEnumStmt(const CreateEnumStmt *from)
3241 : {
3242 676 : CreateEnumStmt *newnode = makeNode(CreateEnumStmt);
3243 :
3244 676 : COPY_NODE_FIELD(typeName);
3245 676 : COPY_NODE_FIELD(vals);
3246 :
3247 676 : return newnode;
3248 : }
3249 :
3250 : static CreateRangeStmt *
3251 338 : _copyCreateRangeStmt(const CreateRangeStmt *from)
3252 : {
3253 338 : CreateRangeStmt *newnode = makeNode(CreateRangeStmt);
3254 :
3255 338 : COPY_NODE_FIELD(typeName);
3256 338 : COPY_NODE_FIELD(params);
3257 :
3258 338 : return newnode;
3259 : }
3260 :
3261 : static AlterEnumStmt *
3262 792 : _copyAlterEnumStmt(const AlterEnumStmt *from)
3263 : {
3264 792 : AlterEnumStmt *newnode = makeNode(AlterEnumStmt);
3265 :
3266 792 : COPY_NODE_FIELD(typeName);
3267 792 : COPY_STRING_FIELD(oldVal);
3268 792 : COPY_STRING_FIELD(newVal);
3269 792 : COPY_STRING_FIELD(newValNeighbor);
3270 792 : COPY_SCALAR_FIELD(newValIsAfter);
3271 792 : COPY_SCALAR_FIELD(skipIfNewValExists);
3272 :
3273 792 : return newnode;
3274 : }
3275 :
3276 : static ViewStmt *
3277 30382 : _copyViewStmt(const ViewStmt *from)
3278 : {
3279 30382 : ViewStmt *newnode = makeNode(ViewStmt);
3280 :
3281 30382 : COPY_NODE_FIELD(view);
3282 30382 : COPY_NODE_FIELD(aliases);
3283 30382 : COPY_NODE_FIELD(query);
3284 30382 : COPY_SCALAR_FIELD(replace);
3285 30382 : COPY_NODE_FIELD(options);
3286 30382 : COPY_SCALAR_FIELD(withCheckOption);
3287 :
3288 30382 : return newnode;
3289 : }
3290 :
3291 : static LoadStmt *
3292 116 : _copyLoadStmt(const LoadStmt *from)
3293 : {
3294 116 : LoadStmt *newnode = makeNode(LoadStmt);
3295 :
3296 116 : COPY_STRING_FIELD(filename);
3297 :
3298 116 : return newnode;
3299 : }
3300 :
3301 : static CreatedbStmt *
3302 1356 : _copyCreatedbStmt(const CreatedbStmt *from)
3303 : {
3304 1356 : CreatedbStmt *newnode = makeNode(CreatedbStmt);
3305 :
3306 1356 : COPY_STRING_FIELD(dbname);
3307 1356 : COPY_NODE_FIELD(options);
3308 :
3309 1356 : return newnode;
3310 : }
3311 :
3312 : static AlterDatabaseStmt *
3313 92 : _copyAlterDatabaseStmt(const AlterDatabaseStmt *from)
3314 : {
3315 92 : AlterDatabaseStmt *newnode = makeNode(AlterDatabaseStmt);
3316 :
3317 92 : COPY_STRING_FIELD(dbname);
3318 92 : COPY_NODE_FIELD(options);
3319 :
3320 92 : return newnode;
3321 : }
3322 :
3323 : static AlterDatabaseRefreshCollStmt *
3324 12 : _copyAlterDatabaseRefreshCollStmt(const AlterDatabaseRefreshCollStmt *from)
3325 : {
3326 12 : AlterDatabaseRefreshCollStmt *newnode = makeNode(AlterDatabaseRefreshCollStmt);
3327 :
3328 12 : COPY_STRING_FIELD(dbname);
3329 :
3330 12 : return newnode;
3331 : }
3332 :
3333 : static AlterDatabaseSetStmt *
3334 2260 : _copyAlterDatabaseSetStmt(const AlterDatabaseSetStmt *from)
3335 : {
3336 2260 : AlterDatabaseSetStmt *newnode = makeNode(AlterDatabaseSetStmt);
3337 :
3338 2260 : COPY_STRING_FIELD(dbname);
3339 2260 : COPY_NODE_FIELD(setstmt);
3340 :
3341 2260 : return newnode;
3342 : }
3343 :
3344 : static DropdbStmt *
3345 204 : _copyDropdbStmt(const DropdbStmt *from)
3346 : {
3347 204 : DropdbStmt *newnode = makeNode(DropdbStmt);
3348 :
3349 204 : COPY_STRING_FIELD(dbname);
3350 204 : COPY_SCALAR_FIELD(missing_ok);
3351 204 : COPY_NODE_FIELD(options);
3352 :
3353 204 : return newnode;
3354 : }
3355 :
3356 : static AlterSystemStmt *
3357 332 : _copyAlterSystemStmt(const AlterSystemStmt *from)
3358 : {
3359 332 : AlterSystemStmt *newnode = makeNode(AlterSystemStmt);
3360 :
3361 332 : COPY_NODE_FIELD(setstmt);
3362 :
3363 332 : return newnode;
3364 : }
3365 :
3366 : static ClusterStmt *
3367 476 : _copyClusterStmt(const ClusterStmt *from)
3368 : {
3369 476 : ClusterStmt *newnode = makeNode(ClusterStmt);
3370 :
3371 476 : COPY_NODE_FIELD(relation);
3372 476 : COPY_STRING_FIELD(indexname);
3373 476 : COPY_NODE_FIELD(params);
3374 :
3375 476 : return newnode;
3376 : }
3377 :
3378 : static VacuumStmt *
3379 21436 : _copyVacuumStmt(const VacuumStmt *from)
3380 : {
3381 21436 : VacuumStmt *newnode = makeNode(VacuumStmt);
3382 :
3383 21436 : COPY_NODE_FIELD(options);
3384 21436 : COPY_NODE_FIELD(rels);
3385 21436 : COPY_SCALAR_FIELD(is_vacuumcmd);
3386 :
3387 21436 : return newnode;
3388 : }
3389 :
3390 : static VacuumRelation *
3391 21100 : _copyVacuumRelation(const VacuumRelation *from)
3392 : {
3393 21100 : VacuumRelation *newnode = makeNode(VacuumRelation);
3394 :
3395 21100 : COPY_NODE_FIELD(relation);
3396 21100 : COPY_SCALAR_FIELD(oid);
3397 21100 : COPY_NODE_FIELD(va_cols);
3398 :
3399 21100 : return newnode;
3400 : }
3401 :
3402 : static ExplainStmt *
3403 76574 : _copyExplainStmt(const ExplainStmt *from)
3404 : {
3405 76574 : ExplainStmt *newnode = makeNode(ExplainStmt);
3406 :
3407 76574 : COPY_NODE_FIELD(query);
3408 76574 : COPY_NODE_FIELD(options);
3409 :
3410 76574 : return newnode;
3411 : }
3412 :
3413 : static CreateTableAsStmt *
3414 3918 : _copyCreateTableAsStmt(const CreateTableAsStmt *from)
3415 : {
3416 3918 : CreateTableAsStmt *newnode = makeNode(CreateTableAsStmt);
3417 :
3418 3918 : COPY_NODE_FIELD(query);
3419 3918 : COPY_NODE_FIELD(into);
3420 3918 : COPY_SCALAR_FIELD(objtype);
3421 3918 : COPY_SCALAR_FIELD(is_select_into);
3422 3918 : COPY_SCALAR_FIELD(if_not_exists);
3423 :
3424 3918 : return newnode;
3425 : }
3426 :
3427 : static RefreshMatViewStmt *
3428 532 : _copyRefreshMatViewStmt(const RefreshMatViewStmt *from)
3429 : {
3430 532 : RefreshMatViewStmt *newnode = makeNode(RefreshMatViewStmt);
3431 :
3432 532 : COPY_SCALAR_FIELD(concurrent);
3433 532 : COPY_SCALAR_FIELD(skipData);
3434 532 : COPY_NODE_FIELD(relation);
3435 :
3436 532 : return newnode;
3437 : }
3438 :
3439 : static CheckPointStmt *
3440 408 : _copyCheckPointStmt(const CheckPointStmt *from)
3441 : {
3442 408 : CheckPointStmt *newnode = makeNode(CheckPointStmt);
3443 :
3444 :
3445 408 : return newnode;
3446 : }
3447 :
3448 : static DiscardStmt *
3449 60 : _copyDiscardStmt(const DiscardStmt *from)
3450 : {
3451 60 : DiscardStmt *newnode = makeNode(DiscardStmt);
3452 :
3453 60 : COPY_SCALAR_FIELD(target);
3454 :
3455 60 : return newnode;
3456 : }
3457 :
3458 : static LockStmt *
3459 2168 : _copyLockStmt(const LockStmt *from)
3460 : {
3461 2168 : LockStmt *newnode = makeNode(LockStmt);
3462 :
3463 2168 : COPY_NODE_FIELD(relations);
3464 2168 : COPY_SCALAR_FIELD(mode);
3465 2168 : COPY_SCALAR_FIELD(nowait);
3466 :
3467 2168 : return newnode;
3468 : }
3469 :
3470 : static ConstraintsSetStmt *
3471 212 : _copyConstraintsSetStmt(const ConstraintsSetStmt *from)
3472 : {
3473 212 : ConstraintsSetStmt *newnode = makeNode(ConstraintsSetStmt);
3474 :
3475 212 : COPY_NODE_FIELD(constraints);
3476 212 : COPY_SCALAR_FIELD(deferred);
3477 :
3478 212 : return newnode;
3479 : }
3480 :
3481 : static ReindexStmt *
3482 2346 : _copyReindexStmt(const ReindexStmt *from)
3483 : {
3484 2346 : ReindexStmt *newnode = makeNode(ReindexStmt);
3485 :
3486 2346 : COPY_SCALAR_FIELD(kind);
3487 2346 : COPY_NODE_FIELD(relation);
3488 2346 : COPY_STRING_FIELD(name);
3489 2346 : COPY_NODE_FIELD(params);
3490 :
3491 2346 : return newnode;
3492 : }
3493 :
3494 : static CreateConversionStmt *
3495 130 : _copyCreateConversionStmt(const CreateConversionStmt *from)
3496 : {
3497 130 : CreateConversionStmt *newnode = makeNode(CreateConversionStmt);
3498 :
3499 130 : COPY_NODE_FIELD(conversion_name);
3500 130 : COPY_STRING_FIELD(for_encoding_name);
3501 130 : COPY_STRING_FIELD(to_encoding_name);
3502 130 : COPY_NODE_FIELD(func_name);
3503 130 : COPY_SCALAR_FIELD(def);
3504 :
3505 130 : return newnode;
3506 : }
3507 :
3508 : static CreateCastStmt *
3509 548 : _copyCreateCastStmt(const CreateCastStmt *from)
3510 : {
3511 548 : CreateCastStmt *newnode = makeNode(CreateCastStmt);
3512 :
3513 548 : COPY_NODE_FIELD(sourcetype);
3514 548 : COPY_NODE_FIELD(targettype);
3515 548 : COPY_NODE_FIELD(func);
3516 548 : COPY_SCALAR_FIELD(context);
3517 548 : COPY_SCALAR_FIELD(inout);
3518 :
3519 548 : return newnode;
3520 : }
3521 :
3522 : static CreateTransformStmt *
3523 102 : _copyCreateTransformStmt(const CreateTransformStmt *from)
3524 : {
3525 102 : CreateTransformStmt *newnode = makeNode(CreateTransformStmt);
3526 :
3527 102 : COPY_SCALAR_FIELD(replace);
3528 102 : COPY_NODE_FIELD(type_name);
3529 102 : COPY_STRING_FIELD(lang);
3530 102 : COPY_NODE_FIELD(fromsql);
3531 102 : COPY_NODE_FIELD(tosql);
3532 :
3533 102 : return newnode;
3534 : }
3535 :
3536 : static PrepareStmt *
3537 3440 : _copyPrepareStmt(const PrepareStmt *from)
3538 : {
3539 3440 : PrepareStmt *newnode = makeNode(PrepareStmt);
3540 :
3541 3440 : COPY_STRING_FIELD(name);
3542 3440 : COPY_NODE_FIELD(argtypes);
3543 3440 : COPY_NODE_FIELD(query);
3544 :
3545 3440 : return newnode;
3546 : }
3547 :
3548 : static ExecuteStmt *
3549 31008 : _copyExecuteStmt(const ExecuteStmt *from)
3550 : {
3551 31008 : ExecuteStmt *newnode = makeNode(ExecuteStmt);
3552 :
3553 31008 : COPY_STRING_FIELD(name);
3554 31008 : COPY_NODE_FIELD(params);
3555 :
3556 31008 : return newnode;
3557 : }
3558 :
3559 : static DeallocateStmt *
3560 8072 : _copyDeallocateStmt(const DeallocateStmt *from)
3561 : {
3562 8072 : DeallocateStmt *newnode = makeNode(DeallocateStmt);
3563 :
3564 8072 : COPY_STRING_FIELD(name);
3565 8072 : COPY_SCALAR_FIELD(isall);
3566 8072 : COPY_LOCATION_FIELD(location);
3567 :
3568 8072 : return newnode;
3569 : }
3570 :
3571 : static DropOwnedStmt *
3572 296 : _copyDropOwnedStmt(const DropOwnedStmt *from)
3573 : {
3574 296 : DropOwnedStmt *newnode = makeNode(DropOwnedStmt);
3575 :
3576 296 : COPY_NODE_FIELD(roles);
3577 296 : COPY_SCALAR_FIELD(behavior);
3578 :
3579 296 : return newnode;
3580 : }
3581 :
3582 : static ReassignOwnedStmt *
3583 80 : _copyReassignOwnedStmt(const ReassignOwnedStmt *from)
3584 : {
3585 80 : ReassignOwnedStmt *newnode = makeNode(ReassignOwnedStmt);
3586 :
3587 80 : COPY_NODE_FIELD(roles);
3588 80 : COPY_NODE_FIELD(newrole);
3589 :
3590 80 : return newnode;
3591 : }
3592 :
3593 : static AlterTSDictionaryStmt *
3594 80 : _copyAlterTSDictionaryStmt(const AlterTSDictionaryStmt *from)
3595 : {
3596 80 : AlterTSDictionaryStmt *newnode = makeNode(AlterTSDictionaryStmt);
3597 :
3598 80 : COPY_NODE_FIELD(dictname);
3599 80 : COPY_NODE_FIELD(options);
3600 :
3601 80 : return newnode;
3602 : }
3603 :
3604 : static AlterTSConfigurationStmt *
3605 14930 : _copyAlterTSConfigurationStmt(const AlterTSConfigurationStmt *from)
3606 : {
3607 14930 : AlterTSConfigurationStmt *newnode = makeNode(AlterTSConfigurationStmt);
3608 :
3609 14930 : COPY_SCALAR_FIELD(kind);
3610 14930 : COPY_NODE_FIELD(cfgname);
3611 14930 : COPY_NODE_FIELD(tokentype);
3612 14930 : COPY_NODE_FIELD(dicts);
3613 14930 : COPY_SCALAR_FIELD(override);
3614 14930 : COPY_SCALAR_FIELD(replace);
3615 14930 : COPY_SCALAR_FIELD(missing_ok);
3616 :
3617 14930 : return newnode;
3618 : }
3619 :
3620 : static PublicationTable *
3621 2644 : _copyPublicationTable(const PublicationTable *from)
3622 : {
3623 2644 : PublicationTable *newnode = makeNode(PublicationTable);
3624 :
3625 2644 : COPY_NODE_FIELD(relation);
3626 2644 : COPY_NODE_FIELD(whereClause);
3627 2644 : COPY_NODE_FIELD(columns);
3628 :
3629 2644 : return newnode;
3630 : }
3631 :
3632 : static PublicationObjSpec *
3633 3356 : _copyPublicationObjSpec(const PublicationObjSpec *from)
3634 : {
3635 3356 : PublicationObjSpec *newnode = makeNode(PublicationObjSpec);
3636 :
3637 3356 : COPY_SCALAR_FIELD(pubobjtype);
3638 3356 : COPY_STRING_FIELD(name);
3639 3356 : COPY_NODE_FIELD(pubtable);
3640 3356 : COPY_LOCATION_FIELD(location);
3641 :
3642 3356 : return newnode;
3643 : }
3644 :
3645 : static CreatePublicationStmt *
3646 1460 : _copyCreatePublicationStmt(const CreatePublicationStmt *from)
3647 : {
3648 1460 : CreatePublicationStmt *newnode = makeNode(CreatePublicationStmt);
3649 :
3650 1460 : COPY_STRING_FIELD(pubname);
3651 1460 : COPY_NODE_FIELD(options);
3652 1460 : COPY_NODE_FIELD(pubobjects);
3653 1460 : COPY_SCALAR_FIELD(for_all_tables);
3654 :
3655 1460 : return newnode;
3656 : }
3657 :
3658 : static AlterPublicationStmt *
3659 2120 : _copyAlterPublicationStmt(const AlterPublicationStmt *from)
3660 : {
3661 2120 : AlterPublicationStmt *newnode = makeNode(AlterPublicationStmt);
3662 :
3663 2120 : COPY_STRING_FIELD(pubname);
3664 2120 : COPY_NODE_FIELD(options);
3665 2120 : COPY_NODE_FIELD(pubobjects);
3666 2120 : COPY_SCALAR_FIELD(for_all_tables);
3667 2120 : COPY_SCALAR_FIELD(action);
3668 :
3669 2120 : return newnode;
3670 : }
3671 :
3672 : static CreateSubscriptionStmt *
3673 852 : _copyCreateSubscriptionStmt(const CreateSubscriptionStmt *from)
3674 : {
3675 852 : CreateSubscriptionStmt *newnode = makeNode(CreateSubscriptionStmt);
3676 :
3677 852 : COPY_STRING_FIELD(subname);
3678 852 : COPY_STRING_FIELD(conninfo);
3679 852 : COPY_NODE_FIELD(publication);
3680 852 : COPY_NODE_FIELD(options);
3681 :
3682 852 : return newnode;
3683 : }
3684 :
3685 : static AlterSubscriptionStmt *
3686 924 : _copyAlterSubscriptionStmt(const AlterSubscriptionStmt *from)
3687 : {
3688 924 : AlterSubscriptionStmt *newnode = makeNode(AlterSubscriptionStmt);
3689 :
3690 924 : COPY_SCALAR_FIELD(kind);
3691 924 : COPY_STRING_FIELD(subname);
3692 924 : COPY_STRING_FIELD(conninfo);
3693 924 : COPY_NODE_FIELD(publication);
3694 924 : COPY_NODE_FIELD(options);
3695 :
3696 924 : return newnode;
3697 : }
3698 :
3699 : static DropSubscriptionStmt *
3700 408 : _copyDropSubscriptionStmt(const DropSubscriptionStmt *from)
3701 : {
3702 408 : DropSubscriptionStmt *newnode = makeNode(DropSubscriptionStmt);
3703 :
3704 408 : COPY_STRING_FIELD(subname);
3705 408 : COPY_SCALAR_FIELD(missing_ok);
3706 408 : COPY_SCALAR_FIELD(behavior);
3707 :
3708 408 : return newnode;
3709 : }
3710 :
3711 : static PathKey *
3712 0 : _copyPathKey(const PathKey *from)
3713 : {
3714 0 : PathKey *newnode = makeNode(PathKey);
3715 :
3716 0 : COPY_SCALAR_FIELD(pk_eclass);
3717 0 : COPY_SCALAR_FIELD(pk_opfamily);
3718 0 : COPY_SCALAR_FIELD(pk_strategy);
3719 0 : COPY_SCALAR_FIELD(pk_nulls_first);
3720 :
3721 0 : return newnode;
3722 : }
3723 :
3724 : static GroupByOrdering *
3725 0 : _copyGroupByOrdering(const GroupByOrdering *from)
3726 : {
3727 0 : GroupByOrdering *newnode = makeNode(GroupByOrdering);
3728 :
3729 0 : COPY_NODE_FIELD(pathkeys);
3730 0 : COPY_NODE_FIELD(clauses);
3731 :
3732 0 : return newnode;
3733 : }
3734 :
3735 : static RestrictInfo *
3736 0 : _copyRestrictInfo(const RestrictInfo *from)
3737 : {
3738 0 : RestrictInfo *newnode = makeNode(RestrictInfo);
3739 :
3740 0 : COPY_NODE_FIELD(clause);
3741 0 : COPY_SCALAR_FIELD(is_pushed_down);
3742 0 : COPY_SCALAR_FIELD(can_join);
3743 0 : COPY_SCALAR_FIELD(pseudoconstant);
3744 0 : COPY_SCALAR_FIELD(has_clone);
3745 0 : COPY_SCALAR_FIELD(is_clone);
3746 0 : COPY_SCALAR_FIELD(leakproof);
3747 0 : COPY_SCALAR_FIELD(has_volatile);
3748 0 : COPY_SCALAR_FIELD(security_level);
3749 0 : COPY_SCALAR_FIELD(num_base_rels);
3750 0 : COPY_BITMAPSET_FIELD(clause_relids);
3751 0 : COPY_BITMAPSET_FIELD(required_relids);
3752 0 : COPY_BITMAPSET_FIELD(incompatible_relids);
3753 0 : COPY_BITMAPSET_FIELD(outer_relids);
3754 0 : COPY_BITMAPSET_FIELD(left_relids);
3755 0 : COPY_BITMAPSET_FIELD(right_relids);
3756 0 : COPY_NODE_FIELD(orclause);
3757 0 : COPY_SCALAR_FIELD(rinfo_serial);
3758 0 : COPY_SCALAR_FIELD(parent_ec);
3759 0 : COPY_SCALAR_FIELD(eval_cost);
3760 0 : COPY_SCALAR_FIELD(norm_selec);
3761 0 : COPY_SCALAR_FIELD(outer_selec);
3762 0 : COPY_NODE_FIELD(mergeopfamilies);
3763 0 : COPY_SCALAR_FIELD(left_ec);
3764 0 : COPY_SCALAR_FIELD(right_ec);
3765 0 : COPY_SCALAR_FIELD(left_em);
3766 0 : COPY_SCALAR_FIELD(right_em);
3767 0 : newnode->scansel_cache = NIL;
3768 0 : COPY_SCALAR_FIELD(outer_is_left);
3769 0 : COPY_SCALAR_FIELD(hashjoinoperator);
3770 0 : COPY_SCALAR_FIELD(left_bucketsize);
3771 0 : COPY_SCALAR_FIELD(right_bucketsize);
3772 0 : COPY_SCALAR_FIELD(left_mcvfreq);
3773 0 : COPY_SCALAR_FIELD(right_mcvfreq);
3774 0 : COPY_SCALAR_FIELD(left_hasheqoperator);
3775 0 : COPY_SCALAR_FIELD(right_hasheqoperator);
3776 :
3777 0 : return newnode;
3778 : }
3779 :
3780 : static PlaceHolderVar *
3781 8954 : _copyPlaceHolderVar(const PlaceHolderVar *from)
3782 : {
3783 8954 : PlaceHolderVar *newnode = makeNode(PlaceHolderVar);
3784 :
3785 8954 : COPY_NODE_FIELD(phexpr);
3786 8954 : COPY_BITMAPSET_FIELD(phrels);
3787 8954 : COPY_BITMAPSET_FIELD(phnullingrels);
3788 8954 : COPY_SCALAR_FIELD(phid);
3789 8954 : COPY_SCALAR_FIELD(phlevelsup);
3790 :
3791 8954 : return newnode;
3792 : }
3793 :
3794 : static SpecialJoinInfo *
3795 0 : _copySpecialJoinInfo(const SpecialJoinInfo *from)
3796 : {
3797 0 : SpecialJoinInfo *newnode = makeNode(SpecialJoinInfo);
3798 :
3799 0 : COPY_BITMAPSET_FIELD(min_lefthand);
3800 0 : COPY_BITMAPSET_FIELD(min_righthand);
3801 0 : COPY_BITMAPSET_FIELD(syn_lefthand);
3802 0 : COPY_BITMAPSET_FIELD(syn_righthand);
3803 0 : COPY_SCALAR_FIELD(jointype);
3804 0 : COPY_SCALAR_FIELD(ojrelid);
3805 0 : COPY_BITMAPSET_FIELD(commute_above_l);
3806 0 : COPY_BITMAPSET_FIELD(commute_above_r);
3807 0 : COPY_BITMAPSET_FIELD(commute_below_l);
3808 0 : COPY_BITMAPSET_FIELD(commute_below_r);
3809 0 : COPY_SCALAR_FIELD(lhs_strict);
3810 0 : COPY_SCALAR_FIELD(semi_can_btree);
3811 0 : COPY_SCALAR_FIELD(semi_can_hash);
3812 0 : COPY_NODE_FIELD(semi_operators);
3813 0 : COPY_NODE_FIELD(semi_rhs_exprs);
3814 :
3815 0 : return newnode;
3816 : }
3817 :
3818 : static AppendRelInfo *
3819 48840 : _copyAppendRelInfo(const AppendRelInfo *from)
3820 : {
3821 48840 : AppendRelInfo *newnode = makeNode(AppendRelInfo);
3822 :
3823 48840 : COPY_SCALAR_FIELD(parent_relid);
3824 48840 : COPY_SCALAR_FIELD(child_relid);
3825 48840 : COPY_SCALAR_FIELD(parent_reltype);
3826 48840 : COPY_SCALAR_FIELD(child_reltype);
3827 48840 : COPY_NODE_FIELD(translated_vars);
3828 48840 : COPY_SCALAR_FIELD(num_child_cols);
3829 48840 : COPY_POINTER_FIELD(parent_colnos, from->num_child_cols * sizeof(AttrNumber));
3830 48840 : COPY_SCALAR_FIELD(parent_reloid);
3831 :
3832 48840 : return newnode;
3833 : }
3834 :
3835 : static PlaceHolderInfo *
3836 0 : _copyPlaceHolderInfo(const PlaceHolderInfo *from)
3837 : {
3838 0 : PlaceHolderInfo *newnode = makeNode(PlaceHolderInfo);
3839 :
3840 0 : COPY_SCALAR_FIELD(phid);
3841 0 : COPY_NODE_FIELD(ph_var);
3842 0 : COPY_BITMAPSET_FIELD(ph_eval_at);
3843 0 : COPY_BITMAPSET_FIELD(ph_lateral);
3844 0 : COPY_BITMAPSET_FIELD(ph_needed);
3845 0 : COPY_SCALAR_FIELD(ph_width);
3846 :
3847 0 : return newnode;
3848 : }
3849 :
3850 : static PlannedStmt *
3851 550712 : _copyPlannedStmt(const PlannedStmt *from)
3852 : {
3853 550712 : PlannedStmt *newnode = makeNode(PlannedStmt);
3854 :
3855 550712 : COPY_SCALAR_FIELD(commandType);
3856 550712 : COPY_SCALAR_FIELD(queryId);
3857 550712 : COPY_SCALAR_FIELD(hasReturning);
3858 550712 : COPY_SCALAR_FIELD(hasModifyingCTE);
3859 550712 : COPY_SCALAR_FIELD(canSetTag);
3860 550712 : COPY_SCALAR_FIELD(transientPlan);
3861 550712 : COPY_SCALAR_FIELD(dependsOnRole);
3862 550712 : COPY_SCALAR_FIELD(parallelModeNeeded);
3863 550712 : COPY_SCALAR_FIELD(jitFlags);
3864 550712 : COPY_NODE_FIELD(planTree);
3865 550712 : COPY_NODE_FIELD(rtable);
3866 550712 : COPY_NODE_FIELD(permInfos);
3867 550712 : COPY_NODE_FIELD(resultRelations);
3868 550712 : COPY_NODE_FIELD(appendRelations);
3869 550712 : COPY_NODE_FIELD(subplans);
3870 550712 : COPY_BITMAPSET_FIELD(rewindPlanIDs);
3871 550712 : COPY_NODE_FIELD(rowMarks);
3872 550712 : COPY_NODE_FIELD(relationOids);
3873 550712 : COPY_NODE_FIELD(invalItems);
3874 550712 : COPY_NODE_FIELD(paramExecTypes);
3875 550712 : COPY_NODE_FIELD(utilityStmt);
3876 550712 : COPY_LOCATION_FIELD(stmt_location);
3877 550712 : COPY_LOCATION_FIELD(stmt_len);
3878 :
3879 550712 : return newnode;
3880 : }
3881 :
3882 : static Result *
3883 263674 : _copyResult(const Result *from)
3884 : {
3885 263674 : Result *newnode = makeNode(Result);
3886 :
3887 263674 : COPY_SCALAR_FIELD(plan.disabled_nodes);
3888 263674 : COPY_SCALAR_FIELD(plan.startup_cost);
3889 263674 : COPY_SCALAR_FIELD(plan.total_cost);
3890 263674 : COPY_SCALAR_FIELD(plan.plan_rows);
3891 263674 : COPY_SCALAR_FIELD(plan.plan_width);
3892 263674 : COPY_SCALAR_FIELD(plan.parallel_aware);
3893 263674 : COPY_SCALAR_FIELD(plan.parallel_safe);
3894 263674 : COPY_SCALAR_FIELD(plan.async_capable);
3895 263674 : COPY_SCALAR_FIELD(plan.plan_node_id);
3896 263674 : COPY_NODE_FIELD(plan.targetlist);
3897 263674 : COPY_NODE_FIELD(plan.qual);
3898 263674 : COPY_NODE_FIELD(plan.lefttree);
3899 263674 : COPY_NODE_FIELD(plan.righttree);
3900 263674 : COPY_NODE_FIELD(plan.initPlan);
3901 263674 : COPY_BITMAPSET_FIELD(plan.extParam);
3902 263674 : COPY_BITMAPSET_FIELD(plan.allParam);
3903 263674 : COPY_NODE_FIELD(resconstantqual);
3904 :
3905 263674 : return newnode;
3906 : }
3907 :
3908 : static ProjectSet *
3909 9030 : _copyProjectSet(const ProjectSet *from)
3910 : {
3911 9030 : ProjectSet *newnode = makeNode(ProjectSet);
3912 :
3913 9030 : COPY_SCALAR_FIELD(plan.disabled_nodes);
3914 9030 : COPY_SCALAR_FIELD(plan.startup_cost);
3915 9030 : COPY_SCALAR_FIELD(plan.total_cost);
3916 9030 : COPY_SCALAR_FIELD(plan.plan_rows);
3917 9030 : COPY_SCALAR_FIELD(plan.plan_width);
3918 9030 : COPY_SCALAR_FIELD(plan.parallel_aware);
3919 9030 : COPY_SCALAR_FIELD(plan.parallel_safe);
3920 9030 : COPY_SCALAR_FIELD(plan.async_capable);
3921 9030 : COPY_SCALAR_FIELD(plan.plan_node_id);
3922 9030 : COPY_NODE_FIELD(plan.targetlist);
3923 9030 : COPY_NODE_FIELD(plan.qual);
3924 9030 : COPY_NODE_FIELD(plan.lefttree);
3925 9030 : COPY_NODE_FIELD(plan.righttree);
3926 9030 : COPY_NODE_FIELD(plan.initPlan);
3927 9030 : COPY_BITMAPSET_FIELD(plan.extParam);
3928 9030 : COPY_BITMAPSET_FIELD(plan.allParam);
3929 :
3930 9030 : return newnode;
3931 : }
3932 :
3933 : static ModifyTable *
3934 98736 : _copyModifyTable(const ModifyTable *from)
3935 : {
3936 98736 : ModifyTable *newnode = makeNode(ModifyTable);
3937 :
3938 98736 : COPY_SCALAR_FIELD(plan.disabled_nodes);
3939 98736 : COPY_SCALAR_FIELD(plan.startup_cost);
3940 98736 : COPY_SCALAR_FIELD(plan.total_cost);
3941 98736 : COPY_SCALAR_FIELD(plan.plan_rows);
3942 98736 : COPY_SCALAR_FIELD(plan.plan_width);
3943 98736 : COPY_SCALAR_FIELD(plan.parallel_aware);
3944 98736 : COPY_SCALAR_FIELD(plan.parallel_safe);
3945 98736 : COPY_SCALAR_FIELD(plan.async_capable);
3946 98736 : COPY_SCALAR_FIELD(plan.plan_node_id);
3947 98736 : COPY_NODE_FIELD(plan.targetlist);
3948 98736 : COPY_NODE_FIELD(plan.qual);
3949 98736 : COPY_NODE_FIELD(plan.lefttree);
3950 98736 : COPY_NODE_FIELD(plan.righttree);
3951 98736 : COPY_NODE_FIELD(plan.initPlan);
3952 98736 : COPY_BITMAPSET_FIELD(plan.extParam);
3953 98736 : COPY_BITMAPSET_FIELD(plan.allParam);
3954 98736 : COPY_SCALAR_FIELD(operation);
3955 98736 : COPY_SCALAR_FIELD(canSetTag);
3956 98736 : COPY_SCALAR_FIELD(nominalRelation);
3957 98736 : COPY_SCALAR_FIELD(rootRelation);
3958 98736 : COPY_SCALAR_FIELD(partColsUpdated);
3959 98736 : COPY_NODE_FIELD(resultRelations);
3960 98736 : COPY_NODE_FIELD(updateColnosLists);
3961 98736 : COPY_NODE_FIELD(withCheckOptionLists);
3962 98736 : COPY_NODE_FIELD(returningLists);
3963 98736 : COPY_NODE_FIELD(fdwPrivLists);
3964 98736 : COPY_BITMAPSET_FIELD(fdwDirectModifyPlans);
3965 98736 : COPY_NODE_FIELD(rowMarks);
3966 98736 : COPY_SCALAR_FIELD(epqParam);
3967 98736 : COPY_SCALAR_FIELD(onConflictAction);
3968 98736 : COPY_NODE_FIELD(arbiterIndexes);
3969 98736 : COPY_NODE_FIELD(onConflictSet);
3970 98736 : COPY_NODE_FIELD(onConflictCols);
3971 98736 : COPY_NODE_FIELD(onConflictWhere);
3972 98736 : COPY_SCALAR_FIELD(exclRelRTI);
3973 98736 : COPY_NODE_FIELD(exclRelTlist);
3974 98736 : COPY_NODE_FIELD(mergeActionLists);
3975 98736 : COPY_NODE_FIELD(mergeJoinConditions);
3976 :
3977 98736 : return newnode;
3978 : }
3979 :
3980 : static Append *
3981 14638 : _copyAppend(const Append *from)
3982 : {
3983 14638 : Append *newnode = makeNode(Append);
3984 :
3985 14638 : COPY_SCALAR_FIELD(plan.disabled_nodes);
3986 14638 : COPY_SCALAR_FIELD(plan.startup_cost);
3987 14638 : COPY_SCALAR_FIELD(plan.total_cost);
3988 14638 : COPY_SCALAR_FIELD(plan.plan_rows);
3989 14638 : COPY_SCALAR_FIELD(plan.plan_width);
3990 14638 : COPY_SCALAR_FIELD(plan.parallel_aware);
3991 14638 : COPY_SCALAR_FIELD(plan.parallel_safe);
3992 14638 : COPY_SCALAR_FIELD(plan.async_capable);
3993 14638 : COPY_SCALAR_FIELD(plan.plan_node_id);
3994 14638 : COPY_NODE_FIELD(plan.targetlist);
3995 14638 : COPY_NODE_FIELD(plan.qual);
3996 14638 : COPY_NODE_FIELD(plan.lefttree);
3997 14638 : COPY_NODE_FIELD(plan.righttree);
3998 14638 : COPY_NODE_FIELD(plan.initPlan);
3999 14638 : COPY_BITMAPSET_FIELD(plan.extParam);
4000 14638 : COPY_BITMAPSET_FIELD(plan.allParam);
4001 14638 : COPY_BITMAPSET_FIELD(apprelids);
4002 14638 : COPY_NODE_FIELD(appendplans);
4003 14638 : COPY_SCALAR_FIELD(nasyncplans);
4004 14638 : COPY_SCALAR_FIELD(first_partial_plan);
4005 14638 : COPY_NODE_FIELD(part_prune_info);
4006 :
4007 14638 : return newnode;
4008 : }
4009 :
4010 : static MergeAppend *
4011 538 : _copyMergeAppend(const MergeAppend *from)
4012 : {
4013 538 : MergeAppend *newnode = makeNode(MergeAppend);
4014 :
4015 538 : COPY_SCALAR_FIELD(plan.disabled_nodes);
4016 538 : COPY_SCALAR_FIELD(plan.startup_cost);
4017 538 : COPY_SCALAR_FIELD(plan.total_cost);
4018 538 : COPY_SCALAR_FIELD(plan.plan_rows);
4019 538 : COPY_SCALAR_FIELD(plan.plan_width);
4020 538 : COPY_SCALAR_FIELD(plan.parallel_aware);
4021 538 : COPY_SCALAR_FIELD(plan.parallel_safe);
4022 538 : COPY_SCALAR_FIELD(plan.async_capable);
4023 538 : COPY_SCALAR_FIELD(plan.plan_node_id);
4024 538 : COPY_NODE_FIELD(plan.targetlist);
4025 538 : COPY_NODE_FIELD(plan.qual);
4026 538 : COPY_NODE_FIELD(plan.lefttree);
4027 538 : COPY_NODE_FIELD(plan.righttree);
4028 538 : COPY_NODE_FIELD(plan.initPlan);
4029 538 : COPY_BITMAPSET_FIELD(plan.extParam);
4030 538 : COPY_BITMAPSET_FIELD(plan.allParam);
4031 538 : COPY_BITMAPSET_FIELD(apprelids);
4032 538 : COPY_NODE_FIELD(mergeplans);
4033 538 : COPY_SCALAR_FIELD(numCols);
4034 538 : COPY_POINTER_FIELD(sortColIdx, from->numCols * sizeof(AttrNumber));
4035 538 : COPY_POINTER_FIELD(sortOperators, from->numCols * sizeof(Oid));
4036 538 : COPY_POINTER_FIELD(collations, from->numCols * sizeof(Oid));
4037 538 : COPY_POINTER_FIELD(nullsFirst, from->numCols * sizeof(bool));
4038 538 : COPY_NODE_FIELD(part_prune_info);
4039 :
4040 538 : return newnode;
4041 : }
4042 :
4043 : static RecursiveUnion *
4044 804 : _copyRecursiveUnion(const RecursiveUnion *from)
4045 : {
4046 804 : RecursiveUnion *newnode = makeNode(RecursiveUnion);
4047 :
4048 804 : COPY_SCALAR_FIELD(plan.disabled_nodes);
4049 804 : COPY_SCALAR_FIELD(plan.startup_cost);
4050 804 : COPY_SCALAR_FIELD(plan.total_cost);
4051 804 : COPY_SCALAR_FIELD(plan.plan_rows);
4052 804 : COPY_SCALAR_FIELD(plan.plan_width);
4053 804 : COPY_SCALAR_FIELD(plan.parallel_aware);
4054 804 : COPY_SCALAR_FIELD(plan.parallel_safe);
4055 804 : COPY_SCALAR_FIELD(plan.async_capable);
4056 804 : COPY_SCALAR_FIELD(plan.plan_node_id);
4057 804 : COPY_NODE_FIELD(plan.targetlist);
4058 804 : COPY_NODE_FIELD(plan.qual);
4059 804 : COPY_NODE_FIELD(plan.lefttree);
4060 804 : COPY_NODE_FIELD(plan.righttree);
4061 804 : COPY_NODE_FIELD(plan.initPlan);
4062 804 : COPY_BITMAPSET_FIELD(plan.extParam);
4063 804 : COPY_BITMAPSET_FIELD(plan.allParam);
4064 804 : COPY_SCALAR_FIELD(wtParam);
4065 804 : COPY_SCALAR_FIELD(numCols);
4066 804 : COPY_POINTER_FIELD(dupColIdx, from->numCols * sizeof(AttrNumber));
4067 804 : COPY_POINTER_FIELD(dupOperators, from->numCols * sizeof(Oid));
4068 804 : COPY_POINTER_FIELD(dupCollations, from->numCols * sizeof(Oid));
4069 804 : COPY_SCALAR_FIELD(numGroups);
4070 :
4071 804 : return newnode;
4072 : }
4073 :
4074 : static BitmapAnd *
4075 104 : _copyBitmapAnd(const BitmapAnd *from)
4076 : {
4077 104 : BitmapAnd *newnode = makeNode(BitmapAnd);
4078 :
4079 104 : COPY_SCALAR_FIELD(plan.disabled_nodes);
4080 104 : COPY_SCALAR_FIELD(plan.startup_cost);
4081 104 : COPY_SCALAR_FIELD(plan.total_cost);
4082 104 : COPY_SCALAR_FIELD(plan.plan_rows);
4083 104 : COPY_SCALAR_FIELD(plan.plan_width);
4084 104 : COPY_SCALAR_FIELD(plan.parallel_aware);
4085 104 : COPY_SCALAR_FIELD(plan.parallel_safe);
4086 104 : COPY_SCALAR_FIELD(plan.async_capable);
4087 104 : COPY_SCALAR_FIELD(plan.plan_node_id);
4088 104 : COPY_NODE_FIELD(plan.targetlist);
4089 104 : COPY_NODE_FIELD(plan.qual);
4090 104 : COPY_NODE_FIELD(plan.lefttree);
4091 104 : COPY_NODE_FIELD(plan.righttree);
4092 104 : COPY_NODE_FIELD(plan.initPlan);
4093 104 : COPY_BITMAPSET_FIELD(plan.extParam);
4094 104 : COPY_BITMAPSET_FIELD(plan.allParam);
4095 104 : COPY_NODE_FIELD(bitmapplans);
4096 :
4097 104 : return newnode;
4098 : }
4099 :
4100 : static BitmapOr *
4101 276 : _copyBitmapOr(const BitmapOr *from)
4102 : {
4103 276 : BitmapOr *newnode = makeNode(BitmapOr);
4104 :
4105 276 : COPY_SCALAR_FIELD(plan.disabled_nodes);
4106 276 : COPY_SCALAR_FIELD(plan.startup_cost);
4107 276 : COPY_SCALAR_FIELD(plan.total_cost);
4108 276 : COPY_SCALAR_FIELD(plan.plan_rows);
4109 276 : COPY_SCALAR_FIELD(plan.plan_width);
4110 276 : COPY_SCALAR_FIELD(plan.parallel_aware);
4111 276 : COPY_SCALAR_FIELD(plan.parallel_safe);
4112 276 : COPY_SCALAR_FIELD(plan.async_capable);
4113 276 : COPY_SCALAR_FIELD(plan.plan_node_id);
4114 276 : COPY_NODE_FIELD(plan.targetlist);
4115 276 : COPY_NODE_FIELD(plan.qual);
4116 276 : COPY_NODE_FIELD(plan.lefttree);
4117 276 : COPY_NODE_FIELD(plan.righttree);
4118 276 : COPY_NODE_FIELD(plan.initPlan);
4119 276 : COPY_BITMAPSET_FIELD(plan.extParam);
4120 276 : COPY_BITMAPSET_FIELD(plan.allParam);
4121 276 : COPY_SCALAR_FIELD(isshared);
4122 276 : COPY_NODE_FIELD(bitmapplans);
4123 :
4124 276 : return newnode;
4125 : }
4126 :
4127 : static SeqScan *
4128 200354 : _copySeqScan(const SeqScan *from)
4129 : {
4130 200354 : SeqScan *newnode = makeNode(SeqScan);
4131 :
4132 200354 : COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
4133 200354 : COPY_SCALAR_FIELD(scan.plan.startup_cost);
4134 200354 : COPY_SCALAR_FIELD(scan.plan.total_cost);
4135 200354 : COPY_SCALAR_FIELD(scan.plan.plan_rows);
4136 200354 : COPY_SCALAR_FIELD(scan.plan.plan_width);
4137 200354 : COPY_SCALAR_FIELD(scan.plan.parallel_aware);
4138 200354 : COPY_SCALAR_FIELD(scan.plan.parallel_safe);
4139 200354 : COPY_SCALAR_FIELD(scan.plan.async_capable);
4140 200354 : COPY_SCALAR_FIELD(scan.plan.plan_node_id);
4141 200354 : COPY_NODE_FIELD(scan.plan.targetlist);
4142 200354 : COPY_NODE_FIELD(scan.plan.qual);
4143 200354 : COPY_NODE_FIELD(scan.plan.lefttree);
4144 200354 : COPY_NODE_FIELD(scan.plan.righttree);
4145 200354 : COPY_NODE_FIELD(scan.plan.initPlan);
4146 200354 : COPY_BITMAPSET_FIELD(scan.plan.extParam);
4147 200354 : COPY_BITMAPSET_FIELD(scan.plan.allParam);
4148 200354 : COPY_SCALAR_FIELD(scan.scanrelid);
4149 :
4150 200354 : return newnode;
4151 : }
4152 :
4153 : static SampleScan *
4154 306 : _copySampleScan(const SampleScan *from)
4155 : {
4156 306 : SampleScan *newnode = makeNode(SampleScan);
4157 :
4158 306 : COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
4159 306 : COPY_SCALAR_FIELD(scan.plan.startup_cost);
4160 306 : COPY_SCALAR_FIELD(scan.plan.total_cost);
4161 306 : COPY_SCALAR_FIELD(scan.plan.plan_rows);
4162 306 : COPY_SCALAR_FIELD(scan.plan.plan_width);
4163 306 : COPY_SCALAR_FIELD(scan.plan.parallel_aware);
4164 306 : COPY_SCALAR_FIELD(scan.plan.parallel_safe);
4165 306 : COPY_SCALAR_FIELD(scan.plan.async_capable);
4166 306 : COPY_SCALAR_FIELD(scan.plan.plan_node_id);
4167 306 : COPY_NODE_FIELD(scan.plan.targetlist);
4168 306 : COPY_NODE_FIELD(scan.plan.qual);
4169 306 : COPY_NODE_FIELD(scan.plan.lefttree);
4170 306 : COPY_NODE_FIELD(scan.plan.righttree);
4171 306 : COPY_NODE_FIELD(scan.plan.initPlan);
4172 306 : COPY_BITMAPSET_FIELD(scan.plan.extParam);
4173 306 : COPY_BITMAPSET_FIELD(scan.plan.allParam);
4174 306 : COPY_SCALAR_FIELD(scan.scanrelid);
4175 306 : COPY_NODE_FIELD(tablesample);
4176 :
4177 306 : return newnode;
4178 : }
4179 :
4180 : static IndexScan *
4181 146374 : _copyIndexScan(const IndexScan *from)
4182 : {
4183 146374 : IndexScan *newnode = makeNode(IndexScan);
4184 :
4185 146374 : COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
4186 146374 : COPY_SCALAR_FIELD(scan.plan.startup_cost);
4187 146374 : COPY_SCALAR_FIELD(scan.plan.total_cost);
4188 146374 : COPY_SCALAR_FIELD(scan.plan.plan_rows);
4189 146374 : COPY_SCALAR_FIELD(scan.plan.plan_width);
4190 146374 : COPY_SCALAR_FIELD(scan.plan.parallel_aware);
4191 146374 : COPY_SCALAR_FIELD(scan.plan.parallel_safe);
4192 146374 : COPY_SCALAR_FIELD(scan.plan.async_capable);
4193 146374 : COPY_SCALAR_FIELD(scan.plan.plan_node_id);
4194 146374 : COPY_NODE_FIELD(scan.plan.targetlist);
4195 146374 : COPY_NODE_FIELD(scan.plan.qual);
4196 146374 : COPY_NODE_FIELD(scan.plan.lefttree);
4197 146374 : COPY_NODE_FIELD(scan.plan.righttree);
4198 146374 : COPY_NODE_FIELD(scan.plan.initPlan);
4199 146374 : COPY_BITMAPSET_FIELD(scan.plan.extParam);
4200 146374 : COPY_BITMAPSET_FIELD(scan.plan.allParam);
4201 146374 : COPY_SCALAR_FIELD(scan.scanrelid);
4202 146374 : COPY_SCALAR_FIELD(indexid);
4203 146374 : COPY_NODE_FIELD(indexqual);
4204 146374 : COPY_NODE_FIELD(indexqualorig);
4205 146374 : COPY_NODE_FIELD(indexorderby);
4206 146374 : COPY_NODE_FIELD(indexorderbyorig);
4207 146374 : COPY_NODE_FIELD(indexorderbyops);
4208 146374 : COPY_SCALAR_FIELD(indexorderdir);
4209 :
4210 146374 : return newnode;
4211 : }
4212 :
4213 : static IndexOnlyScan *
4214 17238 : _copyIndexOnlyScan(const IndexOnlyScan *from)
4215 : {
4216 17238 : IndexOnlyScan *newnode = makeNode(IndexOnlyScan);
4217 :
4218 17238 : COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
4219 17238 : COPY_SCALAR_FIELD(scan.plan.startup_cost);
4220 17238 : COPY_SCALAR_FIELD(scan.plan.total_cost);
4221 17238 : COPY_SCALAR_FIELD(scan.plan.plan_rows);
4222 17238 : COPY_SCALAR_FIELD(scan.plan.plan_width);
4223 17238 : COPY_SCALAR_FIELD(scan.plan.parallel_aware);
4224 17238 : COPY_SCALAR_FIELD(scan.plan.parallel_safe);
4225 17238 : COPY_SCALAR_FIELD(scan.plan.async_capable);
4226 17238 : COPY_SCALAR_FIELD(scan.plan.plan_node_id);
4227 17238 : COPY_NODE_FIELD(scan.plan.targetlist);
4228 17238 : COPY_NODE_FIELD(scan.plan.qual);
4229 17238 : COPY_NODE_FIELD(scan.plan.lefttree);
4230 17238 : COPY_NODE_FIELD(scan.plan.righttree);
4231 17238 : COPY_NODE_FIELD(scan.plan.initPlan);
4232 17238 : COPY_BITMAPSET_FIELD(scan.plan.extParam);
4233 17238 : COPY_BITMAPSET_FIELD(scan.plan.allParam);
4234 17238 : COPY_SCALAR_FIELD(scan.scanrelid);
4235 17238 : COPY_SCALAR_FIELD(indexid);
4236 17238 : COPY_NODE_FIELD(indexqual);
4237 17238 : COPY_NODE_FIELD(recheckqual);
4238 17238 : COPY_NODE_FIELD(indexorderby);
4239 17238 : COPY_NODE_FIELD(indextlist);
4240 17238 : COPY_SCALAR_FIELD(indexorderdir);
4241 :
4242 17238 : return newnode;
4243 : }
4244 :
4245 : static BitmapIndexScan *
4246 21346 : _copyBitmapIndexScan(const BitmapIndexScan *from)
4247 : {
4248 21346 : BitmapIndexScan *newnode = makeNode(BitmapIndexScan);
4249 :
4250 21346 : COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
4251 21346 : COPY_SCALAR_FIELD(scan.plan.startup_cost);
4252 21346 : COPY_SCALAR_FIELD(scan.plan.total_cost);
4253 21346 : COPY_SCALAR_FIELD(scan.plan.plan_rows);
4254 21346 : COPY_SCALAR_FIELD(scan.plan.plan_width);
4255 21346 : COPY_SCALAR_FIELD(scan.plan.parallel_aware);
4256 21346 : COPY_SCALAR_FIELD(scan.plan.parallel_safe);
4257 21346 : COPY_SCALAR_FIELD(scan.plan.async_capable);
4258 21346 : COPY_SCALAR_FIELD(scan.plan.plan_node_id);
4259 21346 : COPY_NODE_FIELD(scan.plan.targetlist);
4260 21346 : COPY_NODE_FIELD(scan.plan.qual);
4261 21346 : COPY_NODE_FIELD(scan.plan.lefttree);
4262 21346 : COPY_NODE_FIELD(scan.plan.righttree);
4263 21346 : COPY_NODE_FIELD(scan.plan.initPlan);
4264 21346 : COPY_BITMAPSET_FIELD(scan.plan.extParam);
4265 21346 : COPY_BITMAPSET_FIELD(scan.plan.allParam);
4266 21346 : COPY_SCALAR_FIELD(scan.scanrelid);
4267 21346 : COPY_SCALAR_FIELD(indexid);
4268 21346 : COPY_SCALAR_FIELD(isshared);
4269 21346 : COPY_NODE_FIELD(indexqual);
4270 21346 : COPY_NODE_FIELD(indexqualorig);
4271 :
4272 21346 : return newnode;
4273 : }
4274 :
4275 : static BitmapHeapScan *
4276 20912 : _copyBitmapHeapScan(const BitmapHeapScan *from)
4277 : {
4278 20912 : BitmapHeapScan *newnode = makeNode(BitmapHeapScan);
4279 :
4280 20912 : COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
4281 20912 : COPY_SCALAR_FIELD(scan.plan.startup_cost);
4282 20912 : COPY_SCALAR_FIELD(scan.plan.total_cost);
4283 20912 : COPY_SCALAR_FIELD(scan.plan.plan_rows);
4284 20912 : COPY_SCALAR_FIELD(scan.plan.plan_width);
4285 20912 : COPY_SCALAR_FIELD(scan.plan.parallel_aware);
4286 20912 : COPY_SCALAR_FIELD(scan.plan.parallel_safe);
4287 20912 : COPY_SCALAR_FIELD(scan.plan.async_capable);
4288 20912 : COPY_SCALAR_FIELD(scan.plan.plan_node_id);
4289 20912 : COPY_NODE_FIELD(scan.plan.targetlist);
4290 20912 : COPY_NODE_FIELD(scan.plan.qual);
4291 20912 : COPY_NODE_FIELD(scan.plan.lefttree);
4292 20912 : COPY_NODE_FIELD(scan.plan.righttree);
4293 20912 : COPY_NODE_FIELD(scan.plan.initPlan);
4294 20912 : COPY_BITMAPSET_FIELD(scan.plan.extParam);
4295 20912 : COPY_BITMAPSET_FIELD(scan.plan.allParam);
4296 20912 : COPY_SCALAR_FIELD(scan.scanrelid);
4297 20912 : COPY_NODE_FIELD(bitmapqualorig);
4298 :
4299 20912 : return newnode;
4300 : }
4301 :
4302 : static TidScan *
4303 904 : _copyTidScan(const TidScan *from)
4304 : {
4305 904 : TidScan *newnode = makeNode(TidScan);
4306 :
4307 904 : COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
4308 904 : COPY_SCALAR_FIELD(scan.plan.startup_cost);
4309 904 : COPY_SCALAR_FIELD(scan.plan.total_cost);
4310 904 : COPY_SCALAR_FIELD(scan.plan.plan_rows);
4311 904 : COPY_SCALAR_FIELD(scan.plan.plan_width);
4312 904 : COPY_SCALAR_FIELD(scan.plan.parallel_aware);
4313 904 : COPY_SCALAR_FIELD(scan.plan.parallel_safe);
4314 904 : COPY_SCALAR_FIELD(scan.plan.async_capable);
4315 904 : COPY_SCALAR_FIELD(scan.plan.plan_node_id);
4316 904 : COPY_NODE_FIELD(scan.plan.targetlist);
4317 904 : COPY_NODE_FIELD(scan.plan.qual);
4318 904 : COPY_NODE_FIELD(scan.plan.lefttree);
4319 904 : COPY_NODE_FIELD(scan.plan.righttree);
4320 904 : COPY_NODE_FIELD(scan.plan.initPlan);
4321 904 : COPY_BITMAPSET_FIELD(scan.plan.extParam);
4322 904 : COPY_BITMAPSET_FIELD(scan.plan.allParam);
4323 904 : COPY_SCALAR_FIELD(scan.scanrelid);
4324 904 : COPY_NODE_FIELD(tidquals);
4325 :
4326 904 : return newnode;
4327 : }
4328 :
4329 : static TidRangeScan *
4330 208 : _copyTidRangeScan(const TidRangeScan *from)
4331 : {
4332 208 : TidRangeScan *newnode = makeNode(TidRangeScan);
4333 :
4334 208 : COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
4335 208 : COPY_SCALAR_FIELD(scan.plan.startup_cost);
4336 208 : COPY_SCALAR_FIELD(scan.plan.total_cost);
4337 208 : COPY_SCALAR_FIELD(scan.plan.plan_rows);
4338 208 : COPY_SCALAR_FIELD(scan.plan.plan_width);
4339 208 : COPY_SCALAR_FIELD(scan.plan.parallel_aware);
4340 208 : COPY_SCALAR_FIELD(scan.plan.parallel_safe);
4341 208 : COPY_SCALAR_FIELD(scan.plan.async_capable);
4342 208 : COPY_SCALAR_FIELD(scan.plan.plan_node_id);
4343 208 : COPY_NODE_FIELD(scan.plan.targetlist);
4344 208 : COPY_NODE_FIELD(scan.plan.qual);
4345 208 : COPY_NODE_FIELD(scan.plan.lefttree);
4346 208 : COPY_NODE_FIELD(scan.plan.righttree);
4347 208 : COPY_NODE_FIELD(scan.plan.initPlan);
4348 208 : COPY_BITMAPSET_FIELD(scan.plan.extParam);
4349 208 : COPY_BITMAPSET_FIELD(scan.plan.allParam);
4350 208 : COPY_SCALAR_FIELD(scan.scanrelid);
4351 208 : COPY_NODE_FIELD(tidrangequals);
4352 :
4353 208 : return newnode;
4354 : }
4355 :
4356 : static SubqueryScan *
4357 11854 : _copySubqueryScan(const SubqueryScan *from)
4358 : {
4359 11854 : SubqueryScan *newnode = makeNode(SubqueryScan);
4360 :
4361 11854 : COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
4362 11854 : COPY_SCALAR_FIELD(scan.plan.startup_cost);
4363 11854 : COPY_SCALAR_FIELD(scan.plan.total_cost);
4364 11854 : COPY_SCALAR_FIELD(scan.plan.plan_rows);
4365 11854 : COPY_SCALAR_FIELD(scan.plan.plan_width);
4366 11854 : COPY_SCALAR_FIELD(scan.plan.parallel_aware);
4367 11854 : COPY_SCALAR_FIELD(scan.plan.parallel_safe);
4368 11854 : COPY_SCALAR_FIELD(scan.plan.async_capable);
4369 11854 : COPY_SCALAR_FIELD(scan.plan.plan_node_id);
4370 11854 : COPY_NODE_FIELD(scan.plan.targetlist);
4371 11854 : COPY_NODE_FIELD(scan.plan.qual);
4372 11854 : COPY_NODE_FIELD(scan.plan.lefttree);
4373 11854 : COPY_NODE_FIELD(scan.plan.righttree);
4374 11854 : COPY_NODE_FIELD(scan.plan.initPlan);
4375 11854 : COPY_BITMAPSET_FIELD(scan.plan.extParam);
4376 11854 : COPY_BITMAPSET_FIELD(scan.plan.allParam);
4377 11854 : COPY_SCALAR_FIELD(scan.scanrelid);
4378 11854 : COPY_NODE_FIELD(subplan);
4379 11854 : COPY_SCALAR_FIELD(scanstatus);
4380 :
4381 11854 : return newnode;
4382 : }
4383 :
4384 : static FunctionScan *
4385 44182 : _copyFunctionScan(const FunctionScan *from)
4386 : {
4387 44182 : FunctionScan *newnode = makeNode(FunctionScan);
4388 :
4389 44182 : COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
4390 44182 : COPY_SCALAR_FIELD(scan.plan.startup_cost);
4391 44182 : COPY_SCALAR_FIELD(scan.plan.total_cost);
4392 44182 : COPY_SCALAR_FIELD(scan.plan.plan_rows);
4393 44182 : COPY_SCALAR_FIELD(scan.plan.plan_width);
4394 44182 : COPY_SCALAR_FIELD(scan.plan.parallel_aware);
4395 44182 : COPY_SCALAR_FIELD(scan.plan.parallel_safe);
4396 44182 : COPY_SCALAR_FIELD(scan.plan.async_capable);
4397 44182 : COPY_SCALAR_FIELD(scan.plan.plan_node_id);
4398 44182 : COPY_NODE_FIELD(scan.plan.targetlist);
4399 44182 : COPY_NODE_FIELD(scan.plan.qual);
4400 44182 : COPY_NODE_FIELD(scan.plan.lefttree);
4401 44182 : COPY_NODE_FIELD(scan.plan.righttree);
4402 44182 : COPY_NODE_FIELD(scan.plan.initPlan);
4403 44182 : COPY_BITMAPSET_FIELD(scan.plan.extParam);
4404 44182 : COPY_BITMAPSET_FIELD(scan.plan.allParam);
4405 44182 : COPY_SCALAR_FIELD(scan.scanrelid);
4406 44182 : COPY_NODE_FIELD(functions);
4407 44182 : COPY_SCALAR_FIELD(funcordinality);
4408 :
4409 44182 : return newnode;
4410 : }
4411 :
4412 : static ValuesScan *
4413 8038 : _copyValuesScan(const ValuesScan *from)
4414 : {
4415 8038 : ValuesScan *newnode = makeNode(ValuesScan);
4416 :
4417 8038 : COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
4418 8038 : COPY_SCALAR_FIELD(scan.plan.startup_cost);
4419 8038 : COPY_SCALAR_FIELD(scan.plan.total_cost);
4420 8038 : COPY_SCALAR_FIELD(scan.plan.plan_rows);
4421 8038 : COPY_SCALAR_FIELD(scan.plan.plan_width);
4422 8038 : COPY_SCALAR_FIELD(scan.plan.parallel_aware);
4423 8038 : COPY_SCALAR_FIELD(scan.plan.parallel_safe);
4424 8038 : COPY_SCALAR_FIELD(scan.plan.async_capable);
4425 8038 : COPY_SCALAR_FIELD(scan.plan.plan_node_id);
4426 8038 : COPY_NODE_FIELD(scan.plan.targetlist);
4427 8038 : COPY_NODE_FIELD(scan.plan.qual);
4428 8038 : COPY_NODE_FIELD(scan.plan.lefttree);
4429 8038 : COPY_NODE_FIELD(scan.plan.righttree);
4430 8038 : COPY_NODE_FIELD(scan.plan.initPlan);
4431 8038 : COPY_BITMAPSET_FIELD(scan.plan.extParam);
4432 8038 : COPY_BITMAPSET_FIELD(scan.plan.allParam);
4433 8038 : COPY_SCALAR_FIELD(scan.scanrelid);
4434 8038 : COPY_NODE_FIELD(values_lists);
4435 :
4436 8038 : return newnode;
4437 : }
4438 :
4439 : static TableFuncScan *
4440 632 : _copyTableFuncScan(const TableFuncScan *from)
4441 : {
4442 632 : TableFuncScan *newnode = makeNode(TableFuncScan);
4443 :
4444 632 : COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
4445 632 : COPY_SCALAR_FIELD(scan.plan.startup_cost);
4446 632 : COPY_SCALAR_FIELD(scan.plan.total_cost);
4447 632 : COPY_SCALAR_FIELD(scan.plan.plan_rows);
4448 632 : COPY_SCALAR_FIELD(scan.plan.plan_width);
4449 632 : COPY_SCALAR_FIELD(scan.plan.parallel_aware);
4450 632 : COPY_SCALAR_FIELD(scan.plan.parallel_safe);
4451 632 : COPY_SCALAR_FIELD(scan.plan.async_capable);
4452 632 : COPY_SCALAR_FIELD(scan.plan.plan_node_id);
4453 632 : COPY_NODE_FIELD(scan.plan.targetlist);
4454 632 : COPY_NODE_FIELD(scan.plan.qual);
4455 632 : COPY_NODE_FIELD(scan.plan.lefttree);
4456 632 : COPY_NODE_FIELD(scan.plan.righttree);
4457 632 : COPY_NODE_FIELD(scan.plan.initPlan);
4458 632 : COPY_BITMAPSET_FIELD(scan.plan.extParam);
4459 632 : COPY_BITMAPSET_FIELD(scan.plan.allParam);
4460 632 : COPY_SCALAR_FIELD(scan.scanrelid);
4461 632 : COPY_NODE_FIELD(tablefunc);
4462 :
4463 632 : return newnode;
4464 : }
4465 :
4466 : static CteScan *
4467 3240 : _copyCteScan(const CteScan *from)
4468 : {
4469 3240 : CteScan *newnode = makeNode(CteScan);
4470 :
4471 3240 : COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
4472 3240 : COPY_SCALAR_FIELD(scan.plan.startup_cost);
4473 3240 : COPY_SCALAR_FIELD(scan.plan.total_cost);
4474 3240 : COPY_SCALAR_FIELD(scan.plan.plan_rows);
4475 3240 : COPY_SCALAR_FIELD(scan.plan.plan_width);
4476 3240 : COPY_SCALAR_FIELD(scan.plan.parallel_aware);
4477 3240 : COPY_SCALAR_FIELD(scan.plan.parallel_safe);
4478 3240 : COPY_SCALAR_FIELD(scan.plan.async_capable);
4479 3240 : COPY_SCALAR_FIELD(scan.plan.plan_node_id);
4480 3240 : COPY_NODE_FIELD(scan.plan.targetlist);
4481 3240 : COPY_NODE_FIELD(scan.plan.qual);
4482 3240 : COPY_NODE_FIELD(scan.plan.lefttree);
4483 3240 : COPY_NODE_FIELD(scan.plan.righttree);
4484 3240 : COPY_NODE_FIELD(scan.plan.initPlan);
4485 3240 : COPY_BITMAPSET_FIELD(scan.plan.extParam);
4486 3240 : COPY_BITMAPSET_FIELD(scan.plan.allParam);
4487 3240 : COPY_SCALAR_FIELD(scan.scanrelid);
4488 3240 : COPY_SCALAR_FIELD(ctePlanId);
4489 3240 : COPY_SCALAR_FIELD(cteParam);
4490 :
4491 3240 : return newnode;
4492 : }
4493 :
4494 : static NamedTuplestoreScan *
4495 852 : _copyNamedTuplestoreScan(const NamedTuplestoreScan *from)
4496 : {
4497 852 : NamedTuplestoreScan *newnode = makeNode(NamedTuplestoreScan);
4498 :
4499 852 : COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
4500 852 : COPY_SCALAR_FIELD(scan.plan.startup_cost);
4501 852 : COPY_SCALAR_FIELD(scan.plan.total_cost);
4502 852 : COPY_SCALAR_FIELD(scan.plan.plan_rows);
4503 852 : COPY_SCALAR_FIELD(scan.plan.plan_width);
4504 852 : COPY_SCALAR_FIELD(scan.plan.parallel_aware);
4505 852 : COPY_SCALAR_FIELD(scan.plan.parallel_safe);
4506 852 : COPY_SCALAR_FIELD(scan.plan.async_capable);
4507 852 : COPY_SCALAR_FIELD(scan.plan.plan_node_id);
4508 852 : COPY_NODE_FIELD(scan.plan.targetlist);
4509 852 : COPY_NODE_FIELD(scan.plan.qual);
4510 852 : COPY_NODE_FIELD(scan.plan.lefttree);
4511 852 : COPY_NODE_FIELD(scan.plan.righttree);
4512 852 : COPY_NODE_FIELD(scan.plan.initPlan);
4513 852 : COPY_BITMAPSET_FIELD(scan.plan.extParam);
4514 852 : COPY_BITMAPSET_FIELD(scan.plan.allParam);
4515 852 : COPY_SCALAR_FIELD(scan.scanrelid);
4516 852 : COPY_STRING_FIELD(enrname);
4517 :
4518 852 : return newnode;
4519 : }
4520 :
4521 : static WorkTableScan *
4522 804 : _copyWorkTableScan(const WorkTableScan *from)
4523 : {
4524 804 : WorkTableScan *newnode = makeNode(WorkTableScan);
4525 :
4526 804 : COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
4527 804 : COPY_SCALAR_FIELD(scan.plan.startup_cost);
4528 804 : COPY_SCALAR_FIELD(scan.plan.total_cost);
4529 804 : COPY_SCALAR_FIELD(scan.plan.plan_rows);
4530 804 : COPY_SCALAR_FIELD(scan.plan.plan_width);
4531 804 : COPY_SCALAR_FIELD(scan.plan.parallel_aware);
4532 804 : COPY_SCALAR_FIELD(scan.plan.parallel_safe);
4533 804 : COPY_SCALAR_FIELD(scan.plan.async_capable);
4534 804 : COPY_SCALAR_FIELD(scan.plan.plan_node_id);
4535 804 : COPY_NODE_FIELD(scan.plan.targetlist);
4536 804 : COPY_NODE_FIELD(scan.plan.qual);
4537 804 : COPY_NODE_FIELD(scan.plan.lefttree);
4538 804 : COPY_NODE_FIELD(scan.plan.righttree);
4539 804 : COPY_NODE_FIELD(scan.plan.initPlan);
4540 804 : COPY_BITMAPSET_FIELD(scan.plan.extParam);
4541 804 : COPY_BITMAPSET_FIELD(scan.plan.allParam);
4542 804 : COPY_SCALAR_FIELD(scan.scanrelid);
4543 804 : COPY_SCALAR_FIELD(wtParam);
4544 :
4545 804 : return newnode;
4546 : }
4547 :
4548 : static ForeignScan *
4549 2032 : _copyForeignScan(const ForeignScan *from)
4550 : {
4551 2032 : ForeignScan *newnode = makeNode(ForeignScan);
4552 :
4553 2032 : COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
4554 2032 : COPY_SCALAR_FIELD(scan.plan.startup_cost);
4555 2032 : COPY_SCALAR_FIELD(scan.plan.total_cost);
4556 2032 : COPY_SCALAR_FIELD(scan.plan.plan_rows);
4557 2032 : COPY_SCALAR_FIELD(scan.plan.plan_width);
4558 2032 : COPY_SCALAR_FIELD(scan.plan.parallel_aware);
4559 2032 : COPY_SCALAR_FIELD(scan.plan.parallel_safe);
4560 2032 : COPY_SCALAR_FIELD(scan.plan.async_capable);
4561 2032 : COPY_SCALAR_FIELD(scan.plan.plan_node_id);
4562 2032 : COPY_NODE_FIELD(scan.plan.targetlist);
4563 2032 : COPY_NODE_FIELD(scan.plan.qual);
4564 2032 : COPY_NODE_FIELD(scan.plan.lefttree);
4565 2032 : COPY_NODE_FIELD(scan.plan.righttree);
4566 2032 : COPY_NODE_FIELD(scan.plan.initPlan);
4567 2032 : COPY_BITMAPSET_FIELD(scan.plan.extParam);
4568 2032 : COPY_BITMAPSET_FIELD(scan.plan.allParam);
4569 2032 : COPY_SCALAR_FIELD(scan.scanrelid);
4570 2032 : COPY_SCALAR_FIELD(operation);
4571 2032 : COPY_SCALAR_FIELD(resultRelation);
4572 2032 : COPY_SCALAR_FIELD(checkAsUser);
4573 2032 : COPY_SCALAR_FIELD(fs_server);
4574 2032 : COPY_NODE_FIELD(fdw_exprs);
4575 2032 : COPY_NODE_FIELD(fdw_private);
4576 2032 : COPY_NODE_FIELD(fdw_scan_tlist);
4577 2032 : COPY_NODE_FIELD(fdw_recheck_quals);
4578 2032 : COPY_BITMAPSET_FIELD(fs_relids);
4579 2032 : COPY_BITMAPSET_FIELD(fs_base_relids);
4580 2032 : COPY_SCALAR_FIELD(fsSystemCol);
4581 :
4582 2032 : return newnode;
4583 : }
4584 :
4585 : static CustomScan *
4586 0 : _copyCustomScan(const CustomScan *from)
4587 : {
4588 0 : CustomScan *newnode = makeNode(CustomScan);
4589 :
4590 0 : COPY_SCALAR_FIELD(scan.plan.disabled_nodes);
4591 0 : COPY_SCALAR_FIELD(scan.plan.startup_cost);
4592 0 : COPY_SCALAR_FIELD(scan.plan.total_cost);
4593 0 : COPY_SCALAR_FIELD(scan.plan.plan_rows);
4594 0 : COPY_SCALAR_FIELD(scan.plan.plan_width);
4595 0 : COPY_SCALAR_FIELD(scan.plan.parallel_aware);
4596 0 : COPY_SCALAR_FIELD(scan.plan.parallel_safe);
4597 0 : COPY_SCALAR_FIELD(scan.plan.async_capable);
4598 0 : COPY_SCALAR_FIELD(scan.plan.plan_node_id);
4599 0 : COPY_NODE_FIELD(scan.plan.targetlist);
4600 0 : COPY_NODE_FIELD(scan.plan.qual);
4601 0 : COPY_NODE_FIELD(scan.plan.lefttree);
4602 0 : COPY_NODE_FIELD(scan.plan.righttree);
4603 0 : COPY_NODE_FIELD(scan.plan.initPlan);
4604 0 : COPY_BITMAPSET_FIELD(scan.plan.extParam);
4605 0 : COPY_BITMAPSET_FIELD(scan.plan.allParam);
4606 0 : COPY_SCALAR_FIELD(scan.scanrelid);
4607 0 : COPY_SCALAR_FIELD(flags);
4608 0 : COPY_NODE_FIELD(custom_plans);
4609 0 : COPY_NODE_FIELD(custom_exprs);
4610 0 : COPY_NODE_FIELD(custom_private);
4611 0 : COPY_NODE_FIELD(custom_scan_tlist);
4612 0 : COPY_BITMAPSET_FIELD(custom_relids);
4613 0 : COPY_SCALAR_FIELD(methods);
4614 :
4615 0 : return newnode;
4616 : }
4617 :
4618 : static NestLoop *
4619 82752 : _copyNestLoop(const NestLoop *from)
4620 : {
4621 82752 : NestLoop *newnode = makeNode(NestLoop);
4622 :
4623 82752 : COPY_SCALAR_FIELD(join.plan.disabled_nodes);
4624 82752 : COPY_SCALAR_FIELD(join.plan.startup_cost);
4625 82752 : COPY_SCALAR_FIELD(join.plan.total_cost);
4626 82752 : COPY_SCALAR_FIELD(join.plan.plan_rows);
4627 82752 : COPY_SCALAR_FIELD(join.plan.plan_width);
4628 82752 : COPY_SCALAR_FIELD(join.plan.parallel_aware);
4629 82752 : COPY_SCALAR_FIELD(join.plan.parallel_safe);
4630 82752 : COPY_SCALAR_FIELD(join.plan.async_capable);
4631 82752 : COPY_SCALAR_FIELD(join.plan.plan_node_id);
4632 82752 : COPY_NODE_FIELD(join.plan.targetlist);
4633 82752 : COPY_NODE_FIELD(join.plan.qual);
4634 82752 : COPY_NODE_FIELD(join.plan.lefttree);
4635 82752 : COPY_NODE_FIELD(join.plan.righttree);
4636 82752 : COPY_NODE_FIELD(join.plan.initPlan);
4637 82752 : COPY_BITMAPSET_FIELD(join.plan.extParam);
4638 82752 : COPY_BITMAPSET_FIELD(join.plan.allParam);
4639 82752 : COPY_SCALAR_FIELD(join.jointype);
4640 82752 : COPY_SCALAR_FIELD(join.inner_unique);
4641 82752 : COPY_NODE_FIELD(join.joinqual);
4642 82752 : COPY_NODE_FIELD(nestParams);
4643 :
4644 82752 : return newnode;
4645 : }
4646 :
4647 : static NestLoopParam *
4648 47064 : _copyNestLoopParam(const NestLoopParam *from)
4649 : {
4650 47064 : NestLoopParam *newnode = makeNode(NestLoopParam);
4651 :
4652 47064 : COPY_SCALAR_FIELD(paramno);
4653 47064 : COPY_NODE_FIELD(paramval);
4654 :
4655 47064 : return newnode;
4656 : }
4657 :
4658 : static MergeJoin *
4659 8384 : _copyMergeJoin(const MergeJoin *from)
4660 : {
4661 8384 : MergeJoin *newnode = makeNode(MergeJoin);
4662 :
4663 8384 : COPY_SCALAR_FIELD(join.plan.disabled_nodes);
4664 8384 : COPY_SCALAR_FIELD(join.plan.startup_cost);
4665 8384 : COPY_SCALAR_FIELD(join.plan.total_cost);
4666 8384 : COPY_SCALAR_FIELD(join.plan.plan_rows);
4667 8384 : COPY_SCALAR_FIELD(join.plan.plan_width);
4668 8384 : COPY_SCALAR_FIELD(join.plan.parallel_aware);
4669 8384 : COPY_SCALAR_FIELD(join.plan.parallel_safe);
4670 8384 : COPY_SCALAR_FIELD(join.plan.async_capable);
4671 8384 : COPY_SCALAR_FIELD(join.plan.plan_node_id);
4672 8384 : COPY_NODE_FIELD(join.plan.targetlist);
4673 8384 : COPY_NODE_FIELD(join.plan.qual);
4674 8384 : COPY_NODE_FIELD(join.plan.lefttree);
4675 8384 : COPY_NODE_FIELD(join.plan.righttree);
4676 8384 : COPY_NODE_FIELD(join.plan.initPlan);
4677 8384 : COPY_BITMAPSET_FIELD(join.plan.extParam);
4678 8384 : COPY_BITMAPSET_FIELD(join.plan.allParam);
4679 8384 : COPY_SCALAR_FIELD(join.jointype);
4680 8384 : COPY_SCALAR_FIELD(join.inner_unique);
4681 8384 : COPY_NODE_FIELD(join.joinqual);
4682 8384 : COPY_SCALAR_FIELD(skip_mark_restore);
4683 8384 : COPY_NODE_FIELD(mergeclauses);
4684 8384 : COPY_POINTER_FIELD(mergeFamilies, list_length(from->mergeclauses) * sizeof(Oid));
4685 8384 : COPY_POINTER_FIELD(mergeCollations, list_length(from->mergeclauses) * sizeof(Oid));
4686 8384 : COPY_POINTER_FIELD(mergeReversals, list_length(from->mergeclauses) * sizeof(bool));
4687 8384 : COPY_POINTER_FIELD(mergeNullsFirst, list_length(from->mergeclauses) * sizeof(bool));
4688 :
4689 8384 : return newnode;
4690 : }
4691 :
4692 : static HashJoin *
4693 33416 : _copyHashJoin(const HashJoin *from)
4694 : {
4695 33416 : HashJoin *newnode = makeNode(HashJoin);
4696 :
4697 33416 : COPY_SCALAR_FIELD(join.plan.disabled_nodes);
4698 33416 : COPY_SCALAR_FIELD(join.plan.startup_cost);
4699 33416 : COPY_SCALAR_FIELD(join.plan.total_cost);
4700 33416 : COPY_SCALAR_FIELD(join.plan.plan_rows);
4701 33416 : COPY_SCALAR_FIELD(join.plan.plan_width);
4702 33416 : COPY_SCALAR_FIELD(join.plan.parallel_aware);
4703 33416 : COPY_SCALAR_FIELD(join.plan.parallel_safe);
4704 33416 : COPY_SCALAR_FIELD(join.plan.async_capable);
4705 33416 : COPY_SCALAR_FIELD(join.plan.plan_node_id);
4706 33416 : COPY_NODE_FIELD(join.plan.targetlist);
4707 33416 : COPY_NODE_FIELD(join.plan.qual);
4708 33416 : COPY_NODE_FIELD(join.plan.lefttree);
4709 33416 : COPY_NODE_FIELD(join.plan.righttree);
4710 33416 : COPY_NODE_FIELD(join.plan.initPlan);
4711 33416 : COPY_BITMAPSET_FIELD(join.plan.extParam);
4712 33416 : COPY_BITMAPSET_FIELD(join.plan.allParam);
4713 33416 : COPY_SCALAR_FIELD(join.jointype);
4714 33416 : COPY_SCALAR_FIELD(join.inner_unique);
4715 33416 : COPY_NODE_FIELD(join.joinqual);
4716 33416 : COPY_NODE_FIELD(hashclauses);
4717 33416 : COPY_NODE_FIELD(hashoperators);
4718 33416 : COPY_NODE_FIELD(hashcollations);
4719 33416 : COPY_NODE_FIELD(hashkeys);
4720 :
4721 33416 : return newnode;
4722 : }
4723 :
4724 : static Material *
4725 4128 : _copyMaterial(const Material *from)
4726 : {
4727 4128 : Material *newnode = makeNode(Material);
4728 :
4729 4128 : COPY_SCALAR_FIELD(plan.disabled_nodes);
4730 4128 : COPY_SCALAR_FIELD(plan.startup_cost);
4731 4128 : COPY_SCALAR_FIELD(plan.total_cost);
4732 4128 : COPY_SCALAR_FIELD(plan.plan_rows);
4733 4128 : COPY_SCALAR_FIELD(plan.plan_width);
4734 4128 : COPY_SCALAR_FIELD(plan.parallel_aware);
4735 4128 : COPY_SCALAR_FIELD(plan.parallel_safe);
4736 4128 : COPY_SCALAR_FIELD(plan.async_capable);
4737 4128 : COPY_SCALAR_FIELD(plan.plan_node_id);
4738 4128 : COPY_NODE_FIELD(plan.targetlist);
4739 4128 : COPY_NODE_FIELD(plan.qual);
4740 4128 : COPY_NODE_FIELD(plan.lefttree);
4741 4128 : COPY_NODE_FIELD(plan.righttree);
4742 4128 : COPY_NODE_FIELD(plan.initPlan);
4743 4128 : COPY_BITMAPSET_FIELD(plan.extParam);
4744 4128 : COPY_BITMAPSET_FIELD(plan.allParam);
4745 :
4746 4128 : return newnode;
4747 : }
4748 :
4749 : static Memoize *
4750 1392 : _copyMemoize(const Memoize *from)
4751 : {
4752 1392 : Memoize *newnode = makeNode(Memoize);
4753 :
4754 1392 : COPY_SCALAR_FIELD(plan.disabled_nodes);
4755 1392 : COPY_SCALAR_FIELD(plan.startup_cost);
4756 1392 : COPY_SCALAR_FIELD(plan.total_cost);
4757 1392 : COPY_SCALAR_FIELD(plan.plan_rows);
4758 1392 : COPY_SCALAR_FIELD(plan.plan_width);
4759 1392 : COPY_SCALAR_FIELD(plan.parallel_aware);
4760 1392 : COPY_SCALAR_FIELD(plan.parallel_safe);
4761 1392 : COPY_SCALAR_FIELD(plan.async_capable);
4762 1392 : COPY_SCALAR_FIELD(plan.plan_node_id);
4763 1392 : COPY_NODE_FIELD(plan.targetlist);
4764 1392 : COPY_NODE_FIELD(plan.qual);
4765 1392 : COPY_NODE_FIELD(plan.lefttree);
4766 1392 : COPY_NODE_FIELD(plan.righttree);
4767 1392 : COPY_NODE_FIELD(plan.initPlan);
4768 1392 : COPY_BITMAPSET_FIELD(plan.extParam);
4769 1392 : COPY_BITMAPSET_FIELD(plan.allParam);
4770 1392 : COPY_SCALAR_FIELD(numKeys);
4771 1392 : COPY_POINTER_FIELD(hashOperators, from->numKeys * sizeof(Oid));
4772 1392 : COPY_POINTER_FIELD(collations, from->numKeys * sizeof(Oid));
4773 1392 : COPY_NODE_FIELD(param_exprs);
4774 1392 : COPY_SCALAR_FIELD(singlerow);
4775 1392 : COPY_SCALAR_FIELD(binary_mode);
4776 1392 : COPY_SCALAR_FIELD(est_entries);
4777 1392 : COPY_BITMAPSET_FIELD(keyparamids);
4778 :
4779 1392 : return newnode;
4780 : }
4781 :
4782 : static Sort *
4783 70846 : _copySort(const Sort *from)
4784 : {
4785 70846 : Sort *newnode = makeNode(Sort);
4786 :
4787 70846 : COPY_SCALAR_FIELD(plan.disabled_nodes);
4788 70846 : COPY_SCALAR_FIELD(plan.startup_cost);
4789 70846 : COPY_SCALAR_FIELD(plan.total_cost);
4790 70846 : COPY_SCALAR_FIELD(plan.plan_rows);
4791 70846 : COPY_SCALAR_FIELD(plan.plan_width);
4792 70846 : COPY_SCALAR_FIELD(plan.parallel_aware);
4793 70846 : COPY_SCALAR_FIELD(plan.parallel_safe);
4794 70846 : COPY_SCALAR_FIELD(plan.async_capable);
4795 70846 : COPY_SCALAR_FIELD(plan.plan_node_id);
4796 70846 : COPY_NODE_FIELD(plan.targetlist);
4797 70846 : COPY_NODE_FIELD(plan.qual);
4798 70846 : COPY_NODE_FIELD(plan.lefttree);
4799 70846 : COPY_NODE_FIELD(plan.righttree);
4800 70846 : COPY_NODE_FIELD(plan.initPlan);
4801 70846 : COPY_BITMAPSET_FIELD(plan.extParam);
4802 70846 : COPY_BITMAPSET_FIELD(plan.allParam);
4803 70846 : COPY_SCALAR_FIELD(numCols);
4804 70846 : COPY_POINTER_FIELD(sortColIdx, from->numCols * sizeof(AttrNumber));
4805 70846 : COPY_POINTER_FIELD(sortOperators, from->numCols * sizeof(Oid));
4806 70846 : COPY_POINTER_FIELD(collations, from->numCols * sizeof(Oid));
4807 70846 : COPY_POINTER_FIELD(nullsFirst, from->numCols * sizeof(bool));
4808 :
4809 70846 : return newnode;
4810 : }
4811 :
4812 : static IncrementalSort *
4813 708 : _copyIncrementalSort(const IncrementalSort *from)
4814 : {
4815 708 : IncrementalSort *newnode = makeNode(IncrementalSort);
4816 :
4817 708 : COPY_SCALAR_FIELD(sort.plan.disabled_nodes);
4818 708 : COPY_SCALAR_FIELD(sort.plan.startup_cost);
4819 708 : COPY_SCALAR_FIELD(sort.plan.total_cost);
4820 708 : COPY_SCALAR_FIELD(sort.plan.plan_rows);
4821 708 : COPY_SCALAR_FIELD(sort.plan.plan_width);
4822 708 : COPY_SCALAR_FIELD(sort.plan.parallel_aware);
4823 708 : COPY_SCALAR_FIELD(sort.plan.parallel_safe);
4824 708 : COPY_SCALAR_FIELD(sort.plan.async_capable);
4825 708 : COPY_SCALAR_FIELD(sort.plan.plan_node_id);
4826 708 : COPY_NODE_FIELD(sort.plan.targetlist);
4827 708 : COPY_NODE_FIELD(sort.plan.qual);
4828 708 : COPY_NODE_FIELD(sort.plan.lefttree);
4829 708 : COPY_NODE_FIELD(sort.plan.righttree);
4830 708 : COPY_NODE_FIELD(sort.plan.initPlan);
4831 708 : COPY_BITMAPSET_FIELD(sort.plan.extParam);
4832 708 : COPY_BITMAPSET_FIELD(sort.plan.allParam);
4833 708 : COPY_SCALAR_FIELD(sort.numCols);
4834 708 : COPY_POINTER_FIELD(sort.sortColIdx, from->sort.numCols * sizeof(AttrNumber));
4835 708 : COPY_POINTER_FIELD(sort.sortOperators, from->sort.numCols * sizeof(Oid));
4836 708 : COPY_POINTER_FIELD(sort.collations, from->sort.numCols * sizeof(Oid));
4837 708 : COPY_POINTER_FIELD(sort.nullsFirst, from->sort.numCols * sizeof(bool));
4838 708 : COPY_SCALAR_FIELD(nPresortedCols);
4839 :
4840 708 : return newnode;
4841 : }
4842 :
4843 : static Group *
4844 246 : _copyGroup(const Group *from)
4845 : {
4846 246 : Group *newnode = makeNode(Group);
4847 :
4848 246 : COPY_SCALAR_FIELD(plan.disabled_nodes);
4849 246 : COPY_SCALAR_FIELD(plan.startup_cost);
4850 246 : COPY_SCALAR_FIELD(plan.total_cost);
4851 246 : COPY_SCALAR_FIELD(plan.plan_rows);
4852 246 : COPY_SCALAR_FIELD(plan.plan_width);
4853 246 : COPY_SCALAR_FIELD(plan.parallel_aware);
4854 246 : COPY_SCALAR_FIELD(plan.parallel_safe);
4855 246 : COPY_SCALAR_FIELD(plan.async_capable);
4856 246 : COPY_SCALAR_FIELD(plan.plan_node_id);
4857 246 : COPY_NODE_FIELD(plan.targetlist);
4858 246 : COPY_NODE_FIELD(plan.qual);
4859 246 : COPY_NODE_FIELD(plan.lefttree);
4860 246 : COPY_NODE_FIELD(plan.righttree);
4861 246 : COPY_NODE_FIELD(plan.initPlan);
4862 246 : COPY_BITMAPSET_FIELD(plan.extParam);
4863 246 : COPY_BITMAPSET_FIELD(plan.allParam);
4864 246 : COPY_SCALAR_FIELD(numCols);
4865 246 : COPY_POINTER_FIELD(grpColIdx, from->numCols * sizeof(AttrNumber));
4866 246 : COPY_POINTER_FIELD(grpOperators, from->numCols * sizeof(Oid));
4867 246 : COPY_POINTER_FIELD(grpCollations, from->numCols * sizeof(Oid));
4868 :
4869 246 : return newnode;
4870 : }
4871 :
4872 : static Agg *
4873 42508 : _copyAgg(const Agg *from)
4874 : {
4875 42508 : Agg *newnode = makeNode(Agg);
4876 :
4877 42508 : COPY_SCALAR_FIELD(plan.disabled_nodes);
4878 42508 : COPY_SCALAR_FIELD(plan.startup_cost);
4879 42508 : COPY_SCALAR_FIELD(plan.total_cost);
4880 42508 : COPY_SCALAR_FIELD(plan.plan_rows);
4881 42508 : COPY_SCALAR_FIELD(plan.plan_width);
4882 42508 : COPY_SCALAR_FIELD(plan.parallel_aware);
4883 42508 : COPY_SCALAR_FIELD(plan.parallel_safe);
4884 42508 : COPY_SCALAR_FIELD(plan.async_capable);
4885 42508 : COPY_SCALAR_FIELD(plan.plan_node_id);
4886 42508 : COPY_NODE_FIELD(plan.targetlist);
4887 42508 : COPY_NODE_FIELD(plan.qual);
4888 42508 : COPY_NODE_FIELD(plan.lefttree);
4889 42508 : COPY_NODE_FIELD(plan.righttree);
4890 42508 : COPY_NODE_FIELD(plan.initPlan);
4891 42508 : COPY_BITMAPSET_FIELD(plan.extParam);
4892 42508 : COPY_BITMAPSET_FIELD(plan.allParam);
4893 42508 : COPY_SCALAR_FIELD(aggstrategy);
4894 42508 : COPY_SCALAR_FIELD(aggsplit);
4895 42508 : COPY_SCALAR_FIELD(numCols);
4896 42508 : COPY_POINTER_FIELD(grpColIdx, from->numCols * sizeof(AttrNumber));
4897 42508 : COPY_POINTER_FIELD(grpOperators, from->numCols * sizeof(Oid));
4898 42508 : COPY_POINTER_FIELD(grpCollations, from->numCols * sizeof(Oid));
4899 42508 : COPY_SCALAR_FIELD(numGroups);
4900 42508 : COPY_SCALAR_FIELD(transitionSpace);
4901 42508 : COPY_BITMAPSET_FIELD(aggParams);
4902 42508 : COPY_NODE_FIELD(groupingSets);
4903 42508 : COPY_NODE_FIELD(chain);
4904 :
4905 42508 : return newnode;
4906 : }
4907 :
4908 : static WindowAgg *
4909 2510 : _copyWindowAgg(const WindowAgg *from)
4910 : {
4911 2510 : WindowAgg *newnode = makeNode(WindowAgg);
4912 :
4913 2510 : COPY_SCALAR_FIELD(plan.disabled_nodes);
4914 2510 : COPY_SCALAR_FIELD(plan.startup_cost);
4915 2510 : COPY_SCALAR_FIELD(plan.total_cost);
4916 2510 : COPY_SCALAR_FIELD(plan.plan_rows);
4917 2510 : COPY_SCALAR_FIELD(plan.plan_width);
4918 2510 : COPY_SCALAR_FIELD(plan.parallel_aware);
4919 2510 : COPY_SCALAR_FIELD(plan.parallel_safe);
4920 2510 : COPY_SCALAR_FIELD(plan.async_capable);
4921 2510 : COPY_SCALAR_FIELD(plan.plan_node_id);
4922 2510 : COPY_NODE_FIELD(plan.targetlist);
4923 2510 : COPY_NODE_FIELD(plan.qual);
4924 2510 : COPY_NODE_FIELD(plan.lefttree);
4925 2510 : COPY_NODE_FIELD(plan.righttree);
4926 2510 : COPY_NODE_FIELD(plan.initPlan);
4927 2510 : COPY_BITMAPSET_FIELD(plan.extParam);
4928 2510 : COPY_BITMAPSET_FIELD(plan.allParam);
4929 2510 : COPY_SCALAR_FIELD(winref);
4930 2510 : COPY_SCALAR_FIELD(partNumCols);
4931 2510 : COPY_POINTER_FIELD(partColIdx, from->partNumCols * sizeof(AttrNumber));
4932 2510 : COPY_POINTER_FIELD(partOperators, from->partNumCols * sizeof(Oid));
4933 2510 : COPY_POINTER_FIELD(partCollations, from->partNumCols * sizeof(Oid));
4934 2510 : COPY_SCALAR_FIELD(ordNumCols);
4935 2510 : COPY_POINTER_FIELD(ordColIdx, from->ordNumCols * sizeof(AttrNumber));
4936 2510 : COPY_POINTER_FIELD(ordOperators, from->ordNumCols * sizeof(Oid));
4937 2510 : COPY_POINTER_FIELD(ordCollations, from->ordNumCols * sizeof(Oid));
4938 2510 : COPY_SCALAR_FIELD(frameOptions);
4939 2510 : COPY_NODE_FIELD(startOffset);
4940 2510 : COPY_NODE_FIELD(endOffset);
4941 2510 : COPY_NODE_FIELD(runCondition);
4942 2510 : COPY_NODE_FIELD(runConditionOrig);
4943 2510 : COPY_SCALAR_FIELD(startInRangeFunc);
4944 2510 : COPY_SCALAR_FIELD(endInRangeFunc);
4945 2510 : COPY_SCALAR_FIELD(inRangeColl);
4946 2510 : COPY_SCALAR_FIELD(inRangeAsc);
4947 2510 : COPY_SCALAR_FIELD(inRangeNullsFirst);
4948 2510 : COPY_SCALAR_FIELD(topWindow);
4949 :
4950 2510 : return newnode;
4951 : }
4952 :
4953 : static Unique *
4954 4874 : _copyUnique(const Unique *from)
4955 : {
4956 4874 : Unique *newnode = makeNode(Unique);
4957 :
4958 4874 : COPY_SCALAR_FIELD(plan.disabled_nodes);
4959 4874 : COPY_SCALAR_FIELD(plan.startup_cost);
4960 4874 : COPY_SCALAR_FIELD(plan.total_cost);
4961 4874 : COPY_SCALAR_FIELD(plan.plan_rows);
4962 4874 : COPY_SCALAR_FIELD(plan.plan_width);
4963 4874 : COPY_SCALAR_FIELD(plan.parallel_aware);
4964 4874 : COPY_SCALAR_FIELD(plan.parallel_safe);
4965 4874 : COPY_SCALAR_FIELD(plan.async_capable);
4966 4874 : COPY_SCALAR_FIELD(plan.plan_node_id);
4967 4874 : COPY_NODE_FIELD(plan.targetlist);
4968 4874 : COPY_NODE_FIELD(plan.qual);
4969 4874 : COPY_NODE_FIELD(plan.lefttree);
4970 4874 : COPY_NODE_FIELD(plan.righttree);
4971 4874 : COPY_NODE_FIELD(plan.initPlan);
4972 4874 : COPY_BITMAPSET_FIELD(plan.extParam);
4973 4874 : COPY_BITMAPSET_FIELD(plan.allParam);
4974 4874 : COPY_SCALAR_FIELD(numCols);
4975 4874 : COPY_POINTER_FIELD(uniqColIdx, from->numCols * sizeof(AttrNumber));
4976 4874 : COPY_POINTER_FIELD(uniqOperators, from->numCols * sizeof(Oid));
4977 4874 : COPY_POINTER_FIELD(uniqCollations, from->numCols * sizeof(Oid));
4978 :
4979 4874 : return newnode;
4980 : }
4981 :
4982 : static Gather *
4983 1060 : _copyGather(const Gather *from)
4984 : {
4985 1060 : Gather *newnode = makeNode(Gather);
4986 :
4987 1060 : COPY_SCALAR_FIELD(plan.disabled_nodes);
4988 1060 : COPY_SCALAR_FIELD(plan.startup_cost);
4989 1060 : COPY_SCALAR_FIELD(plan.total_cost);
4990 1060 : COPY_SCALAR_FIELD(plan.plan_rows);
4991 1060 : COPY_SCALAR_FIELD(plan.plan_width);
4992 1060 : COPY_SCALAR_FIELD(plan.parallel_aware);
4993 1060 : COPY_SCALAR_FIELD(plan.parallel_safe);
4994 1060 : COPY_SCALAR_FIELD(plan.async_capable);
4995 1060 : COPY_SCALAR_FIELD(plan.plan_node_id);
4996 1060 : COPY_NODE_FIELD(plan.targetlist);
4997 1060 : COPY_NODE_FIELD(plan.qual);
4998 1060 : COPY_NODE_FIELD(plan.lefttree);
4999 1060 : COPY_NODE_FIELD(plan.righttree);
5000 1060 : COPY_NODE_FIELD(plan.initPlan);
5001 1060 : COPY_BITMAPSET_FIELD(plan.extParam);
5002 1060 : COPY_BITMAPSET_FIELD(plan.allParam);
5003 1060 : COPY_SCALAR_FIELD(num_workers);
5004 1060 : COPY_SCALAR_FIELD(rescan_param);
5005 1060 : COPY_SCALAR_FIELD(single_copy);
5006 1060 : COPY_SCALAR_FIELD(invisible);
5007 1060 : COPY_BITMAPSET_FIELD(initParam);
5008 :
5009 1060 : return newnode;
5010 : }
5011 :
5012 : static GatherMerge *
5013 318 : _copyGatherMerge(const GatherMerge *from)
5014 : {
5015 318 : GatherMerge *newnode = makeNode(GatherMerge);
5016 :
5017 318 : COPY_SCALAR_FIELD(plan.disabled_nodes);
5018 318 : COPY_SCALAR_FIELD(plan.startup_cost);
5019 318 : COPY_SCALAR_FIELD(plan.total_cost);
5020 318 : COPY_SCALAR_FIELD(plan.plan_rows);
5021 318 : COPY_SCALAR_FIELD(plan.plan_width);
5022 318 : COPY_SCALAR_FIELD(plan.parallel_aware);
5023 318 : COPY_SCALAR_FIELD(plan.parallel_safe);
5024 318 : COPY_SCALAR_FIELD(plan.async_capable);
5025 318 : COPY_SCALAR_FIELD(plan.plan_node_id);
5026 318 : COPY_NODE_FIELD(plan.targetlist);
5027 318 : COPY_NODE_FIELD(plan.qual);
5028 318 : COPY_NODE_FIELD(plan.lefttree);
5029 318 : COPY_NODE_FIELD(plan.righttree);
5030 318 : COPY_NODE_FIELD(plan.initPlan);
5031 318 : COPY_BITMAPSET_FIELD(plan.extParam);
5032 318 : COPY_BITMAPSET_FIELD(plan.allParam);
5033 318 : COPY_SCALAR_FIELD(num_workers);
5034 318 : COPY_SCALAR_FIELD(rescan_param);
5035 318 : COPY_SCALAR_FIELD(numCols);
5036 318 : COPY_POINTER_FIELD(sortColIdx, from->numCols * sizeof(AttrNumber));
5037 318 : COPY_POINTER_FIELD(sortOperators, from->numCols * sizeof(Oid));
5038 318 : COPY_POINTER_FIELD(collations, from->numCols * sizeof(Oid));
5039 318 : COPY_POINTER_FIELD(nullsFirst, from->numCols * sizeof(bool));
5040 318 : COPY_BITMAPSET_FIELD(initParam);
5041 :
5042 318 : return newnode;
5043 : }
5044 :
5045 : static Hash *
5046 33416 : _copyHash(const Hash *from)
5047 : {
5048 33416 : Hash *newnode = makeNode(Hash);
5049 :
5050 33416 : COPY_SCALAR_FIELD(plan.disabled_nodes);
5051 33416 : COPY_SCALAR_FIELD(plan.startup_cost);
5052 33416 : COPY_SCALAR_FIELD(plan.total_cost);
5053 33416 : COPY_SCALAR_FIELD(plan.plan_rows);
5054 33416 : COPY_SCALAR_FIELD(plan.plan_width);
5055 33416 : COPY_SCALAR_FIELD(plan.parallel_aware);
5056 33416 : COPY_SCALAR_FIELD(plan.parallel_safe);
5057 33416 : COPY_SCALAR_FIELD(plan.async_capable);
5058 33416 : COPY_SCALAR_FIELD(plan.plan_node_id);
5059 33416 : COPY_NODE_FIELD(plan.targetlist);
5060 33416 : COPY_NODE_FIELD(plan.qual);
5061 33416 : COPY_NODE_FIELD(plan.lefttree);
5062 33416 : COPY_NODE_FIELD(plan.righttree);
5063 33416 : COPY_NODE_FIELD(plan.initPlan);
5064 33416 : COPY_BITMAPSET_FIELD(plan.extParam);
5065 33416 : COPY_BITMAPSET_FIELD(plan.allParam);
5066 33416 : COPY_NODE_FIELD(hashkeys);
5067 33416 : COPY_SCALAR_FIELD(skewTable);
5068 33416 : COPY_SCALAR_FIELD(skewColumn);
5069 33416 : COPY_SCALAR_FIELD(skewInherit);
5070 33416 : COPY_SCALAR_FIELD(rows_total);
5071 :
5072 33416 : return newnode;
5073 : }
5074 :
5075 : static SetOp *
5076 650 : _copySetOp(const SetOp *from)
5077 : {
5078 650 : SetOp *newnode = makeNode(SetOp);
5079 :
5080 650 : COPY_SCALAR_FIELD(plan.disabled_nodes);
5081 650 : COPY_SCALAR_FIELD(plan.startup_cost);
5082 650 : COPY_SCALAR_FIELD(plan.total_cost);
5083 650 : COPY_SCALAR_FIELD(plan.plan_rows);
5084 650 : COPY_SCALAR_FIELD(plan.plan_width);
5085 650 : COPY_SCALAR_FIELD(plan.parallel_aware);
5086 650 : COPY_SCALAR_FIELD(plan.parallel_safe);
5087 650 : COPY_SCALAR_FIELD(plan.async_capable);
5088 650 : COPY_SCALAR_FIELD(plan.plan_node_id);
5089 650 : COPY_NODE_FIELD(plan.targetlist);
5090 650 : COPY_NODE_FIELD(plan.qual);
5091 650 : COPY_NODE_FIELD(plan.lefttree);
5092 650 : COPY_NODE_FIELD(plan.righttree);
5093 650 : COPY_NODE_FIELD(plan.initPlan);
5094 650 : COPY_BITMAPSET_FIELD(plan.extParam);
5095 650 : COPY_BITMAPSET_FIELD(plan.allParam);
5096 650 : COPY_SCALAR_FIELD(cmd);
5097 650 : COPY_SCALAR_FIELD(strategy);
5098 650 : COPY_SCALAR_FIELD(numCols);
5099 650 : COPY_POINTER_FIELD(dupColIdx, from->numCols * sizeof(AttrNumber));
5100 650 : COPY_POINTER_FIELD(dupOperators, from->numCols * sizeof(Oid));
5101 650 : COPY_POINTER_FIELD(dupCollations, from->numCols * sizeof(Oid));
5102 650 : COPY_SCALAR_FIELD(flagColIdx);
5103 650 : COPY_SCALAR_FIELD(firstFlag);
5104 650 : COPY_SCALAR_FIELD(numGroups);
5105 :
5106 650 : return newnode;
5107 : }
5108 :
5109 : static LockRows *
5110 13698 : _copyLockRows(const LockRows *from)
5111 : {
5112 13698 : LockRows *newnode = makeNode(LockRows);
5113 :
5114 13698 : COPY_SCALAR_FIELD(plan.disabled_nodes);
5115 13698 : COPY_SCALAR_FIELD(plan.startup_cost);
5116 13698 : COPY_SCALAR_FIELD(plan.total_cost);
5117 13698 : COPY_SCALAR_FIELD(plan.plan_rows);
5118 13698 : COPY_SCALAR_FIELD(plan.plan_width);
5119 13698 : COPY_SCALAR_FIELD(plan.parallel_aware);
5120 13698 : COPY_SCALAR_FIELD(plan.parallel_safe);
5121 13698 : COPY_SCALAR_FIELD(plan.async_capable);
5122 13698 : COPY_SCALAR_FIELD(plan.plan_node_id);
5123 13698 : COPY_NODE_FIELD(plan.targetlist);
5124 13698 : COPY_NODE_FIELD(plan.qual);
5125 13698 : COPY_NODE_FIELD(plan.lefttree);
5126 13698 : COPY_NODE_FIELD(plan.righttree);
5127 13698 : COPY_NODE_FIELD(plan.initPlan);
5128 13698 : COPY_BITMAPSET_FIELD(plan.extParam);
5129 13698 : COPY_BITMAPSET_FIELD(plan.allParam);
5130 13698 : COPY_NODE_FIELD(rowMarks);
5131 13698 : COPY_SCALAR_FIELD(epqParam);
5132 :
5133 13698 : return newnode;
5134 : }
5135 :
5136 : static Limit *
5137 4724 : _copyLimit(const Limit *from)
5138 : {
5139 4724 : Limit *newnode = makeNode(Limit);
5140 :
5141 4724 : COPY_SCALAR_FIELD(plan.disabled_nodes);
5142 4724 : COPY_SCALAR_FIELD(plan.startup_cost);
5143 4724 : COPY_SCALAR_FIELD(plan.total_cost);
5144 4724 : COPY_SCALAR_FIELD(plan.plan_rows);
5145 4724 : COPY_SCALAR_FIELD(plan.plan_width);
5146 4724 : COPY_SCALAR_FIELD(plan.parallel_aware);
5147 4724 : COPY_SCALAR_FIELD(plan.parallel_safe);
5148 4724 : COPY_SCALAR_FIELD(plan.async_capable);
5149 4724 : COPY_SCALAR_FIELD(plan.plan_node_id);
5150 4724 : COPY_NODE_FIELD(plan.targetlist);
5151 4724 : COPY_NODE_FIELD(plan.qual);
5152 4724 : COPY_NODE_FIELD(plan.lefttree);
5153 4724 : COPY_NODE_FIELD(plan.righttree);
5154 4724 : COPY_NODE_FIELD(plan.initPlan);
5155 4724 : COPY_BITMAPSET_FIELD(plan.extParam);
5156 4724 : COPY_BITMAPSET_FIELD(plan.allParam);
5157 4724 : COPY_NODE_FIELD(limitOffset);
5158 4724 : COPY_NODE_FIELD(limitCount);
5159 4724 : COPY_SCALAR_FIELD(limitOption);
5160 4724 : COPY_SCALAR_FIELD(uniqNumCols);
5161 4724 : COPY_POINTER_FIELD(uniqColIdx, from->uniqNumCols * sizeof(AttrNumber));
5162 4724 : COPY_POINTER_FIELD(uniqOperators, from->uniqNumCols * sizeof(Oid));
5163 4724 : COPY_POINTER_FIELD(uniqCollations, from->uniqNumCols * sizeof(Oid));
5164 :
5165 4724 : return newnode;
5166 : }
5167 :
5168 : static PlanRowMark *
5169 41416 : _copyPlanRowMark(const PlanRowMark *from)
5170 : {
5171 41416 : PlanRowMark *newnode = makeNode(PlanRowMark);
5172 :
5173 41416 : COPY_SCALAR_FIELD(rti);
5174 41416 : COPY_SCALAR_FIELD(prti);
5175 41416 : COPY_SCALAR_FIELD(rowmarkId);
5176 41416 : COPY_SCALAR_FIELD(markType);
5177 41416 : COPY_SCALAR_FIELD(allMarkTypes);
5178 41416 : COPY_SCALAR_FIELD(strength);
5179 41416 : COPY_SCALAR_FIELD(waitPolicy);
5180 41416 : COPY_SCALAR_FIELD(isParent);
5181 :
5182 41416 : return newnode;
5183 : }
5184 :
5185 : static PartitionPruneInfo *
5186 712 : _copyPartitionPruneInfo(const PartitionPruneInfo *from)
5187 : {
5188 712 : PartitionPruneInfo *newnode = makeNode(PartitionPruneInfo);
5189 :
5190 712 : COPY_NODE_FIELD(prune_infos);
5191 712 : COPY_BITMAPSET_FIELD(other_subplans);
5192 :
5193 712 : return newnode;
5194 : }
5195 :
5196 : static PartitionedRelPruneInfo *
5197 1492 : _copyPartitionedRelPruneInfo(const PartitionedRelPruneInfo *from)
5198 : {
5199 1492 : PartitionedRelPruneInfo *newnode = makeNode(PartitionedRelPruneInfo);
5200 :
5201 1492 : COPY_SCALAR_FIELD(rtindex);
5202 1492 : COPY_BITMAPSET_FIELD(present_parts);
5203 1492 : COPY_SCALAR_FIELD(nparts);
5204 1492 : COPY_POINTER_FIELD(subplan_map, from->nparts * sizeof(int));
5205 1492 : COPY_POINTER_FIELD(subpart_map, from->nparts * sizeof(int));
5206 1492 : COPY_POINTER_FIELD(relid_map, from->nparts * sizeof(Oid));
5207 1492 : COPY_NODE_FIELD(initial_pruning_steps);
5208 1492 : COPY_NODE_FIELD(exec_pruning_steps);
5209 1492 : COPY_BITMAPSET_FIELD(execparamids);
5210 :
5211 1492 : return newnode;
5212 : }
5213 :
5214 : static PartitionPruneStepOp *
5215 1382 : _copyPartitionPruneStepOp(const PartitionPruneStepOp *from)
5216 : {
5217 1382 : PartitionPruneStepOp *newnode = makeNode(PartitionPruneStepOp);
5218 :
5219 1382 : COPY_SCALAR_FIELD(step.step_id);
5220 1382 : COPY_SCALAR_FIELD(opstrategy);
5221 1382 : COPY_NODE_FIELD(exprs);
5222 1382 : COPY_NODE_FIELD(cmpfns);
5223 1382 : COPY_BITMAPSET_FIELD(nullkeys);
5224 :
5225 1382 : return newnode;
5226 : }
5227 :
5228 : static PartitionPruneStepCombine *
5229 286 : _copyPartitionPruneStepCombine(const PartitionPruneStepCombine *from)
5230 : {
5231 286 : PartitionPruneStepCombine *newnode = makeNode(PartitionPruneStepCombine);
5232 :
5233 286 : COPY_SCALAR_FIELD(step.step_id);
5234 286 : COPY_SCALAR_FIELD(combineOp);
5235 286 : COPY_NODE_FIELD(source_stepids);
5236 :
5237 286 : return newnode;
5238 : }
5239 :
5240 : static PlanInvalItem *
5241 82190 : _copyPlanInvalItem(const PlanInvalItem *from)
5242 : {
5243 82190 : PlanInvalItem *newnode = makeNode(PlanInvalItem);
5244 :
5245 82190 : COPY_SCALAR_FIELD(cacheId);
5246 82190 : COPY_SCALAR_FIELD(hashValue);
5247 :
5248 82190 : return newnode;
5249 : }
5250 :
5251 : static Integer *
5252 35282 : _copyInteger(const Integer *from)
5253 : {
5254 35282 : Integer *newnode = makeNode(Integer);
5255 :
5256 35282 : COPY_SCALAR_FIELD(ival);
5257 :
5258 35282 : return newnode;
5259 : }
5260 :
5261 : static Float *
5262 260 : _copyFloat(const Float *from)
5263 : {
5264 260 : Float *newnode = makeNode(Float);
5265 :
5266 260 : COPY_STRING_FIELD(fval);
5267 :
5268 260 : return newnode;
5269 : }
5270 :
5271 : static Boolean *
5272 29850 : _copyBoolean(const Boolean *from)
5273 : {
5274 29850 : Boolean *newnode = makeNode(Boolean);
5275 :
5276 29850 : COPY_SCALAR_FIELD(boolval);
5277 :
5278 29850 : return newnode;
5279 : }
5280 :
5281 : static String *
5282 26984448 : _copyString(const String *from)
5283 : {
5284 26984448 : String *newnode = makeNode(String);
5285 :
5286 26984448 : COPY_STRING_FIELD(sval);
5287 :
5288 26984448 : return newnode;
5289 : }
5290 :
5291 : static BitString *
5292 0 : _copyBitString(const BitString *from)
5293 : {
5294 0 : BitString *newnode = makeNode(BitString);
5295 :
5296 0 : COPY_STRING_FIELD(bsval);
5297 :
5298 0 : return newnode;
5299 : }
5300 :
5301 : static ForeignKeyCacheInfo *
5302 3396 : _copyForeignKeyCacheInfo(const ForeignKeyCacheInfo *from)
5303 : {
5304 3396 : ForeignKeyCacheInfo *newnode = makeNode(ForeignKeyCacheInfo);
5305 :
5306 3396 : COPY_SCALAR_FIELD(conoid);
5307 3396 : COPY_SCALAR_FIELD(conrelid);
5308 3396 : COPY_SCALAR_FIELD(confrelid);
5309 3396 : COPY_SCALAR_FIELD(nkeys);
5310 3396 : COPY_ARRAY_FIELD(conkey);
5311 3396 : COPY_ARRAY_FIELD(confkey);
5312 3396 : COPY_ARRAY_FIELD(conpfeqop);
5313 :
5314 3396 : return newnode;
5315 : }
|
