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