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