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