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