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