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