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