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