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