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