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