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