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