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