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 1950110 : _readAlias(void)
44 : {
45 1950110 : READ_LOCALS(Alias);
46 :
47 1950110 : READ_STRING_FIELD(aliasname);
48 1950110 : READ_NODE_FIELD(colnames);
49 :
50 1950110 : READ_DONE();
51 : }
52 :
53 : static RangeVar *
54 574805 : _readRangeVar(void)
55 : {
56 574805 : READ_LOCALS(RangeVar);
57 :
58 574805 : READ_STRING_FIELD(catalogname);
59 574805 : READ_STRING_FIELD(schemaname);
60 574805 : READ_STRING_FIELD(relname);
61 574805 : READ_BOOL_FIELD(inh);
62 574805 : READ_CHAR_FIELD(relpersistence);
63 574805 : READ_NODE_FIELD(alias);
64 574805 : READ_LOCATION_FIELD(location);
65 :
66 574805 : 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 2565 : _readIntoClause(void)
97 : {
98 2565 : READ_LOCALS(IntoClause);
99 :
100 2565 : READ_NODE_FIELD(rel);
101 2565 : READ_NODE_FIELD(colNames);
102 2565 : READ_STRING_FIELD(accessMethod);
103 2565 : READ_NODE_FIELD(options);
104 2565 : READ_ENUM_FIELD(onCommit, OnCommitAction);
105 2565 : READ_STRING_FIELD(tableSpaceName);
106 2565 : READ_NODE_FIELD(viewQuery);
107 2565 : READ_BOOL_FIELD(skipData);
108 :
109 2565 : READ_DONE();
110 : }
111 :
112 : static Var *
113 9371300 : _readVar(void)
114 : {
115 9371300 : READ_LOCALS(Var);
116 :
117 9371300 : READ_INT_FIELD(varno);
118 9371300 : READ_INT_FIELD(varattno);
119 9371300 : READ_OID_FIELD(vartype);
120 9371300 : READ_INT_FIELD(vartypmod);
121 9371300 : READ_OID_FIELD(varcollid);
122 9371300 : READ_BITMAPSET_FIELD(varnullingrels);
123 9371300 : READ_UINT_FIELD(varlevelsup);
124 9371300 : READ_ENUM_FIELD(varreturningtype, VarReturningType);
125 9371300 : READ_UINT_FIELD(varnosyn);
126 9371300 : READ_INT_FIELD(varattnosyn);
127 9371300 : READ_LOCATION_FIELD(location);
128 :
129 9371300 : READ_DONE();
130 : }
131 :
132 : static Param *
133 221127 : _readParam(void)
134 : {
135 221127 : READ_LOCALS(Param);
136 :
137 221127 : READ_ENUM_FIELD(paramkind, ParamKind);
138 221127 : READ_INT_FIELD(paramid);
139 221127 : READ_OID_FIELD(paramtype);
140 221127 : READ_INT_FIELD(paramtypmod);
141 221127 : READ_OID_FIELD(paramcollid);
142 221127 : READ_LOCATION_FIELD(location);
143 :
144 221127 : READ_DONE();
145 : }
146 :
147 : static Aggref *
148 70873 : _readAggref(void)
149 : {
150 70873 : READ_LOCALS(Aggref);
151 :
152 70873 : READ_OID_FIELD(aggfnoid);
153 70873 : READ_OID_FIELD(aggtype);
154 70873 : READ_OID_FIELD(aggcollid);
155 70873 : READ_OID_FIELD(inputcollid);
156 70873 : READ_OID_FIELD(aggtranstype);
157 70873 : READ_NODE_FIELD(aggargtypes);
158 70873 : READ_NODE_FIELD(aggdirectargs);
159 70873 : READ_NODE_FIELD(args);
160 70873 : READ_NODE_FIELD(aggorder);
161 70873 : READ_NODE_FIELD(aggdistinct);
162 70873 : READ_NODE_FIELD(aggfilter);
163 70873 : READ_BOOL_FIELD(aggstar);
164 70873 : READ_BOOL_FIELD(aggvariadic);
165 70873 : READ_CHAR_FIELD(aggkind);
166 70873 : READ_BOOL_FIELD(aggpresorted);
167 70873 : READ_UINT_FIELD(agglevelsup);
168 70873 : READ_ENUM_FIELD(aggsplit, AggSplit);
169 70873 : READ_INT_FIELD(aggno);
170 70873 : READ_INT_FIELD(aggtransno);
171 70873 : READ_LOCATION_FIELD(location);
172 :
173 70873 : 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 5318 : _readWindowFunc(void)
192 : {
193 5318 : READ_LOCALS(WindowFunc);
194 :
195 5318 : READ_OID_FIELD(winfnoid);
196 5318 : READ_OID_FIELD(wintype);
197 5318 : READ_OID_FIELD(wincollid);
198 5318 : READ_OID_FIELD(inputcollid);
199 5318 : READ_NODE_FIELD(args);
200 5318 : READ_NODE_FIELD(aggfilter);
201 5318 : READ_NODE_FIELD(runCondition);
202 5318 : READ_UINT_FIELD(winref);
203 5318 : READ_BOOL_FIELD(winstar);
204 5318 : READ_BOOL_FIELD(winagg);
205 5318 : READ_INT_FIELD(ignore_nulls);
206 5318 : READ_LOCATION_FIELD(location);
207 :
208 5318 : 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 28248 : _readSubscriptingRef(void)
238 : {
239 28248 : READ_LOCALS(SubscriptingRef);
240 :
241 28248 : READ_OID_FIELD(refcontainertype);
242 28248 : READ_OID_FIELD(refelemtype);
243 28248 : READ_OID_FIELD(refrestype);
244 28248 : READ_INT_FIELD(reftypmod);
245 28248 : READ_OID_FIELD(refcollid);
246 28248 : READ_NODE_FIELD(refupperindexpr);
247 28248 : READ_NODE_FIELD(reflowerindexpr);
248 28248 : READ_NODE_FIELD(refexpr);
249 28248 : READ_NODE_FIELD(refassgnexpr);
250 :
251 28248 : READ_DONE();
252 : }
253 :
254 : static FuncExpr *
255 628601 : _readFuncExpr(void)
256 : {
257 628601 : READ_LOCALS(FuncExpr);
258 :
259 628601 : READ_OID_FIELD(funcid);
260 628601 : READ_OID_FIELD(funcresulttype);
261 628601 : READ_BOOL_FIELD(funcretset);
262 628601 : READ_BOOL_FIELD(funcvariadic);
263 628601 : READ_ENUM_FIELD(funcformat, CoercionForm);
264 628601 : READ_OID_FIELD(funccollid);
265 628601 : READ_OID_FIELD(inputcollid);
266 628601 : READ_NODE_FIELD(args);
267 628601 : READ_LOCATION_FIELD(location);
268 :
269 628601 : READ_DONE();
270 : }
271 :
272 : static NamedArgExpr *
273 50937 : _readNamedArgExpr(void)
274 : {
275 50937 : READ_LOCALS(NamedArgExpr);
276 :
277 50937 : READ_NODE_FIELD(arg);
278 50937 : READ_STRING_FIELD(name);
279 50937 : READ_INT_FIELD(argnumber);
280 50937 : READ_LOCATION_FIELD(location);
281 :
282 50937 : READ_DONE();
283 : }
284 :
285 : static OpExpr *
286 1106701 : _readOpExpr(void)
287 : {
288 1106701 : READ_LOCALS(OpExpr);
289 :
290 1106701 : READ_OID_FIELD(opno);
291 1106701 : READ_OID_FIELD(opfuncid);
292 1106701 : READ_OID_FIELD(opresulttype);
293 1106701 : READ_BOOL_FIELD(opretset);
294 1106701 : READ_OID_FIELD(opcollid);
295 1106701 : READ_OID_FIELD(inputcollid);
296 1106701 : READ_NODE_FIELD(args);
297 1106701 : READ_LOCATION_FIELD(location);
298 :
299 1106701 : READ_DONE();
300 : }
301 :
302 : static DistinctExpr *
303 1564 : _readDistinctExpr(void)
304 : {
305 1564 : READ_LOCALS(DistinctExpr);
306 :
307 1564 : READ_OID_FIELD(opno);
308 1564 : READ_OID_FIELD(opfuncid);
309 1564 : READ_OID_FIELD(opresulttype);
310 1564 : READ_BOOL_FIELD(opretset);
311 1564 : READ_OID_FIELD(opcollid);
312 1564 : READ_OID_FIELD(inputcollid);
313 1564 : READ_NODE_FIELD(args);
314 1564 : READ_LOCATION_FIELD(location);
315 :
316 1564 : READ_DONE();
317 : }
318 :
319 : static NullIfExpr *
320 1102 : _readNullIfExpr(void)
321 : {
322 1102 : READ_LOCALS(NullIfExpr);
323 :
324 1102 : READ_OID_FIELD(opno);
325 1102 : READ_OID_FIELD(opfuncid);
326 1102 : READ_OID_FIELD(opresulttype);
327 1102 : READ_BOOL_FIELD(opretset);
328 1102 : READ_OID_FIELD(opcollid);
329 1102 : READ_OID_FIELD(inputcollid);
330 1102 : READ_NODE_FIELD(args);
331 1102 : READ_LOCATION_FIELD(location);
332 :
333 1102 : READ_DONE();
334 : }
335 :
336 : static ScalarArrayOpExpr *
337 51699 : _readScalarArrayOpExpr(void)
338 : {
339 51699 : READ_LOCALS(ScalarArrayOpExpr);
340 :
341 51699 : READ_OID_FIELD(opno);
342 51699 : READ_OID_FIELD(opfuncid);
343 51699 : READ_OID_FIELD(hashfuncid);
344 51699 : READ_OID_FIELD(negfuncid);
345 51699 : READ_BOOL_FIELD(useOr);
346 51699 : READ_OID_FIELD(inputcollid);
347 51699 : READ_NODE_FIELD(args);
348 51699 : READ_LOCATION_FIELD(location);
349 :
350 51699 : READ_DONE();
351 : }
352 :
353 : static SubLink *
354 73115 : _readSubLink(void)
355 : {
356 73115 : READ_LOCALS(SubLink);
357 :
358 73115 : READ_ENUM_FIELD(subLinkType, SubLinkType);
359 73115 : READ_INT_FIELD(subLinkId);
360 73115 : READ_NODE_FIELD(testexpr);
361 73115 : READ_NODE_FIELD(operName);
362 73115 : READ_NODE_FIELD(subselect);
363 73115 : READ_LOCATION_FIELD(location);
364 :
365 73115 : READ_DONE();
366 : }
367 :
368 : static SubPlan *
369 28757 : _readSubPlan(void)
370 : {
371 28757 : READ_LOCALS(SubPlan);
372 :
373 28757 : READ_ENUM_FIELD(subLinkType, SubLinkType);
374 28757 : READ_NODE_FIELD(testexpr);
375 28757 : READ_NODE_FIELD(paramIds);
376 28757 : READ_INT_FIELD(plan_id);
377 28757 : READ_STRING_FIELD(plan_name);
378 28757 : READ_OID_FIELD(firstColType);
379 28757 : READ_INT_FIELD(firstColTypmod);
380 28757 : READ_OID_FIELD(firstColCollation);
381 28757 : READ_BOOL_FIELD(isInitPlan);
382 28757 : READ_BOOL_FIELD(useHashTable);
383 28757 : READ_BOOL_FIELD(unknownEqFalse);
384 28757 : READ_BOOL_FIELD(parallel_safe);
385 28757 : READ_NODE_FIELD(setParam);
386 28757 : READ_NODE_FIELD(parParam);
387 28757 : READ_NODE_FIELD(args);
388 28757 : READ_INT_FIELD(disabled_nodes);
389 28757 : READ_FLOAT_FIELD(startup_cost);
390 28757 : READ_FLOAT_FIELD(per_call_cost);
391 :
392 28757 : 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 55015 : _readFieldSelect(void)
407 : {
408 55015 : READ_LOCALS(FieldSelect);
409 :
410 55015 : READ_NODE_FIELD(arg);
411 55015 : READ_INT_FIELD(fieldnum);
412 55015 : READ_OID_FIELD(resulttype);
413 55015 : READ_INT_FIELD(resulttypmod);
414 55015 : READ_OID_FIELD(resultcollid);
415 :
416 55015 : 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 178573 : _readRelabelType(void)
434 : {
435 178573 : READ_LOCALS(RelabelType);
436 :
437 178573 : READ_NODE_FIELD(arg);
438 178573 : READ_OID_FIELD(resulttype);
439 178573 : READ_INT_FIELD(resulttypmod);
440 178573 : READ_OID_FIELD(resultcollid);
441 178573 : READ_ENUM_FIELD(relabelformat, CoercionForm);
442 178573 : READ_LOCATION_FIELD(location);
443 :
444 178573 : READ_DONE();
445 : }
446 :
447 : static CoerceViaIO *
448 38782 : _readCoerceViaIO(void)
449 : {
450 38782 : READ_LOCALS(CoerceViaIO);
451 :
452 38782 : READ_NODE_FIELD(arg);
453 38782 : READ_OID_FIELD(resulttype);
454 38782 : READ_OID_FIELD(resultcollid);
455 38782 : READ_ENUM_FIELD(coerceformat, CoercionForm);
456 38782 : READ_LOCATION_FIELD(location);
457 :
458 38782 : READ_DONE();
459 : }
460 :
461 : static ArrayCoerceExpr *
462 7307 : _readArrayCoerceExpr(void)
463 : {
464 7307 : READ_LOCALS(ArrayCoerceExpr);
465 :
466 7307 : READ_NODE_FIELD(arg);
467 7307 : READ_NODE_FIELD(elemexpr);
468 7307 : READ_OID_FIELD(resulttype);
469 7307 : READ_INT_FIELD(resulttypmod);
470 7307 : READ_OID_FIELD(resultcollid);
471 7307 : READ_ENUM_FIELD(coerceformat, CoercionForm);
472 7307 : READ_LOCATION_FIELD(location);
473 :
474 7307 : 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 6836 : _readCollateExpr(void)
492 : {
493 6836 : READ_LOCALS(CollateExpr);
494 :
495 6836 : READ_NODE_FIELD(arg);
496 6836 : READ_OID_FIELD(collOid);
497 6836 : READ_LOCATION_FIELD(location);
498 :
499 6836 : READ_DONE();
500 : }
501 :
502 : static CaseExpr *
503 100875 : _readCaseExpr(void)
504 : {
505 100875 : READ_LOCALS(CaseExpr);
506 :
507 100875 : READ_OID_FIELD(casetype);
508 100875 : READ_OID_FIELD(casecollid);
509 100875 : READ_NODE_FIELD(arg);
510 100875 : READ_NODE_FIELD(args);
511 100875 : READ_NODE_FIELD(defresult);
512 100875 : READ_LOCATION_FIELD(location);
513 :
514 100875 : READ_DONE();
515 : }
516 :
517 : static CaseWhen *
518 204703 : _readCaseWhen(void)
519 : {
520 204703 : READ_LOCALS(CaseWhen);
521 :
522 204703 : READ_NODE_FIELD(expr);
523 204703 : READ_NODE_FIELD(result);
524 204703 : READ_LOCATION_FIELD(location);
525 :
526 204703 : READ_DONE();
527 : }
528 :
529 : static CaseTestExpr *
530 46077 : _readCaseTestExpr(void)
531 : {
532 46077 : READ_LOCALS(CaseTestExpr);
533 :
534 46077 : READ_OID_FIELD(typeId);
535 46077 : READ_INT_FIELD(typeMod);
536 46077 : READ_OID_FIELD(collation);
537 :
538 46077 : READ_DONE();
539 : }
540 :
541 : static ArrayExpr *
542 24080 : _readArrayExpr(void)
543 : {
544 24080 : READ_LOCALS(ArrayExpr);
545 :
546 24080 : READ_OID_FIELD(array_typeid);
547 24080 : READ_OID_FIELD(array_collid);
548 24080 : READ_OID_FIELD(element_typeid);
549 24080 : READ_NODE_FIELD(elements);
550 24080 : READ_BOOL_FIELD(multidims);
551 24080 : READ_LOCATION_FIELD(list_start);
552 24080 : READ_LOCATION_FIELD(list_end);
553 24080 : READ_LOCATION_FIELD(location);
554 :
555 24080 : READ_DONE();
556 : }
557 :
558 : static RowExpr *
559 9085 : _readRowExpr(void)
560 : {
561 9085 : READ_LOCALS(RowExpr);
562 :
563 9085 : READ_NODE_FIELD(args);
564 9085 : READ_OID_FIELD(row_typeid);
565 9085 : READ_ENUM_FIELD(row_format, CoercionForm);
566 9085 : READ_NODE_FIELD(colnames);
567 9085 : READ_LOCATION_FIELD(location);
568 :
569 9085 : 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 12833 : _readCoalesceExpr(void)
589 : {
590 12833 : READ_LOCALS(CoalesceExpr);
591 :
592 12833 : READ_OID_FIELD(coalescetype);
593 12833 : READ_OID_FIELD(coalescecollid);
594 12833 : READ_NODE_FIELD(args);
595 12833 : READ_LOCATION_FIELD(location);
596 :
597 12833 : READ_DONE();
598 : }
599 :
600 : static MinMaxExpr *
601 640 : _readMinMaxExpr(void)
602 : {
603 640 : READ_LOCALS(MinMaxExpr);
604 :
605 640 : READ_OID_FIELD(minmaxtype);
606 640 : READ_OID_FIELD(minmaxcollid);
607 640 : READ_OID_FIELD(inputcollid);
608 640 : READ_ENUM_FIELD(op, MinMaxOp);
609 640 : READ_NODE_FIELD(args);
610 640 : READ_LOCATION_FIELD(location);
611 :
612 640 : READ_DONE();
613 : }
614 :
615 : static SQLValueFunction *
616 9227 : _readSQLValueFunction(void)
617 : {
618 9227 : READ_LOCALS(SQLValueFunction);
619 :
620 9227 : READ_ENUM_FIELD(op, SQLValueFunctionOp);
621 9227 : READ_OID_FIELD(type);
622 9227 : READ_INT_FIELD(typmod);
623 9227 : READ_LOCATION_FIELD(location);
624 :
625 9227 : 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 17770 : _readJsonFormat(void)
649 : {
650 17770 : READ_LOCALS(JsonFormat);
651 :
652 17770 : READ_ENUM_FIELD(format_type, JsonFormatType);
653 17770 : READ_ENUM_FIELD(encoding, JsonEncoding);
654 17770 : READ_LOCATION_FIELD(location);
655 :
656 17770 : READ_DONE();
657 : }
658 :
659 : static JsonReturning *
660 7658 : _readJsonReturning(void)
661 : {
662 7658 : READ_LOCALS(JsonReturning);
663 :
664 7658 : READ_NODE_FIELD(format);
665 7658 : READ_OID_FIELD(typid);
666 7658 : READ_INT_FIELD(typmod);
667 :
668 7658 : READ_DONE();
669 : }
670 :
671 : static JsonValueExpr *
672 4768 : _readJsonValueExpr(void)
673 : {
674 4768 : READ_LOCALS(JsonValueExpr);
675 :
676 4768 : READ_NODE_FIELD(raw_expr);
677 4768 : READ_NODE_FIELD(formatted_expr);
678 4768 : READ_NODE_FIELD(format);
679 :
680 4768 : READ_DONE();
681 : }
682 :
683 : static JsonConstructorExpr *
684 2068 : _readJsonConstructorExpr(void)
685 : {
686 2068 : READ_LOCALS(JsonConstructorExpr);
687 :
688 2068 : READ_ENUM_FIELD(type, JsonConstructorType);
689 2068 : READ_NODE_FIELD(args);
690 2068 : READ_NODE_FIELD(func);
691 2068 : READ_NODE_FIELD(coercion);
692 2068 : READ_NODE_FIELD(returning);
693 2068 : READ_NODE_FIELD(orig_query);
694 2068 : READ_BOOL_FIELD(absent_on_null);
695 2068 : READ_BOOL_FIELD(unique);
696 2068 : READ_LOCATION_FIELD(location);
697 :
698 2068 : READ_DONE();
699 : }
700 :
701 : static JsonIsPredicate *
702 900 : _readJsonIsPredicate(void)
703 : {
704 900 : READ_LOCALS(JsonIsPredicate);
705 :
706 900 : READ_NODE_FIELD(expr);
707 900 : READ_NODE_FIELD(format);
708 900 : READ_ENUM_FIELD(item_type, JsonValueType);
709 900 : READ_BOOL_FIELD(unique_keys);
710 900 : READ_OID_FIELD(exprBaseType);
711 900 : READ_LOCATION_FIELD(location);
712 :
713 900 : 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 37417 : _readNullTest(void)
792 : {
793 37417 : READ_LOCALS(NullTest);
794 :
795 37417 : READ_NODE_FIELD(arg);
796 37417 : READ_ENUM_FIELD(nulltesttype, NullTestType);
797 37417 : READ_BOOL_FIELD(argisrow);
798 37417 : READ_LOCATION_FIELD(location);
799 :
800 37417 : READ_DONE();
801 : }
802 :
803 : static BooleanTest *
804 2689 : _readBooleanTest(void)
805 : {
806 2689 : READ_LOCALS(BooleanTest);
807 :
808 2689 : READ_NODE_FIELD(arg);
809 2689 : READ_ENUM_FIELD(booltesttype, BoolTestType);
810 2689 : READ_LOCATION_FIELD(location);
811 :
812 2689 : READ_DONE();
813 : }
814 :
815 : static MergeAction *
816 4385 : _readMergeAction(void)
817 : {
818 4385 : READ_LOCALS(MergeAction);
819 :
820 4385 : READ_ENUM_FIELD(matchKind, MergeMatchKind);
821 4385 : READ_ENUM_FIELD(commandType, CmdType);
822 4385 : READ_ENUM_FIELD(override, OverridingKind);
823 4385 : READ_NODE_FIELD(qual);
824 4385 : READ_NODE_FIELD(targetList);
825 4385 : READ_NODE_FIELD(updateColnos);
826 :
827 4385 : READ_DONE();
828 : }
829 :
830 : static CoerceToDomain *
831 88119 : _readCoerceToDomain(void)
832 : {
833 88119 : READ_LOCALS(CoerceToDomain);
834 :
835 88119 : READ_NODE_FIELD(arg);
836 88119 : READ_OID_FIELD(resulttype);
837 88119 : READ_INT_FIELD(resulttypmod);
838 88119 : READ_OID_FIELD(resultcollid);
839 88119 : READ_ENUM_FIELD(coercionformat, CoercionForm);
840 88119 : READ_LOCATION_FIELD(location);
841 :
842 88119 : READ_DONE();
843 : }
844 :
845 : static CoerceToDomainValue *
846 1448 : _readCoerceToDomainValue(void)
847 : {
848 1448 : READ_LOCALS(CoerceToDomainValue);
849 :
850 1448 : READ_OID_FIELD(typeId);
851 1448 : READ_INT_FIELD(typeMod);
852 1448 : READ_OID_FIELD(collation);
853 1448 : READ_LOCATION_FIELD(location);
854 :
855 1448 : READ_DONE();
856 : }
857 :
858 : static SetToDefault *
859 1201 : _readSetToDefault(void)
860 : {
861 1201 : READ_LOCALS(SetToDefault);
862 :
863 1201 : READ_OID_FIELD(typeId);
864 1201 : READ_INT_FIELD(typeMod);
865 1201 : READ_OID_FIELD(collation);
866 1201 : READ_LOCATION_FIELD(location);
867 :
868 1201 : 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 1572 : _readInferenceElem(void)
896 : {
897 1572 : READ_LOCALS(InferenceElem);
898 :
899 1572 : READ_NODE_FIELD(expr);
900 1572 : READ_OID_FIELD(infercollid);
901 1572 : READ_OID_FIELD(inferopclass);
902 :
903 1572 : 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 160 : _readGraphPropertyRef(void)
931 : {
932 160 : READ_LOCALS(GraphPropertyRef);
933 :
934 160 : READ_STRING_FIELD(elvarname);
935 160 : READ_OID_FIELD(propid);
936 160 : READ_OID_FIELD(typeId);
937 160 : READ_INT_FIELD(typmod);
938 160 : READ_OID_FIELD(collation);
939 160 : READ_LOCATION_FIELD(location);
940 :
941 160 : READ_DONE();
942 : }
943 :
944 : static TargetEntry *
945 5042054 : _readTargetEntry(void)
946 : {
947 5042054 : READ_LOCALS(TargetEntry);
948 :
949 5042054 : READ_NODE_FIELD(expr);
950 5042054 : READ_INT_FIELD(resno);
951 5042054 : READ_STRING_FIELD(resname);
952 5042054 : READ_UINT_FIELD(ressortgroupref);
953 5042054 : READ_OID_FIELD(resorigtbl);
954 5042054 : READ_INT_FIELD(resorigcol);
955 5042054 : READ_BOOL_FIELD(resjunk);
956 :
957 5042054 : READ_DONE();
958 : }
959 :
960 : static RangeTblRef *
961 446424 : _readRangeTblRef(void)
962 : {
963 446424 : READ_LOCALS(RangeTblRef);
964 :
965 446424 : READ_INT_FIELD(rtindex);
966 :
967 446424 : READ_DONE();
968 : }
969 :
970 : static JoinExpr *
971 151142 : _readJoinExpr(void)
972 : {
973 151142 : READ_LOCALS(JoinExpr);
974 :
975 151142 : READ_ENUM_FIELD(jointype, JoinType);
976 151142 : READ_BOOL_FIELD(isNatural);
977 151142 : READ_NODE_FIELD(larg);
978 151142 : READ_NODE_FIELD(rarg);
979 151142 : READ_NODE_FIELD(usingClause);
980 151142 : READ_NODE_FIELD(join_using_alias);
981 151142 : READ_NODE_FIELD(quals);
982 151142 : READ_NODE_FIELD(alias);
983 151142 : READ_INT_FIELD(rtindex);
984 :
985 151142 : READ_DONE();
986 : }
987 :
988 : static FromExpr *
989 428454 : _readFromExpr(void)
990 : {
991 428454 : READ_LOCALS(FromExpr);
992 :
993 428454 : READ_NODE_FIELD(fromlist);
994 428454 : READ_NODE_FIELD(quals);
995 :
996 428454 : READ_DONE();
997 : }
998 :
999 : static OnConflictExpr *
1000 1556 : _readOnConflictExpr(void)
1001 : {
1002 1556 : READ_LOCALS(OnConflictExpr);
1003 :
1004 1556 : READ_ENUM_FIELD(action, OnConflictAction);
1005 1556 : READ_NODE_FIELD(arbiterElems);
1006 1556 : READ_NODE_FIELD(arbiterWhere);
1007 1556 : READ_OID_FIELD(constraint);
1008 1556 : READ_ENUM_FIELD(lockStrength, LockClauseStrength);
1009 1556 : READ_NODE_FIELD(onConflictSet);
1010 1556 : READ_NODE_FIELD(onConflictWhere);
1011 1556 : READ_INT_FIELD(exclRelIndex);
1012 1556 : READ_NODE_FIELD(exclRelTlist);
1013 :
1014 1556 : READ_DONE();
1015 : }
1016 :
1017 : static ForPortionOfExpr *
1018 1794 : _readForPortionOfExpr(void)
1019 : {
1020 1794 : READ_LOCALS(ForPortionOfExpr);
1021 :
1022 1794 : READ_NODE_FIELD(rangeVar);
1023 1794 : READ_STRING_FIELD(range_name);
1024 1794 : READ_NODE_FIELD(targetFrom);
1025 1794 : READ_NODE_FIELD(targetTo);
1026 1794 : READ_NODE_FIELD(targetRange);
1027 1794 : READ_OID_FIELD(rangeType);
1028 1794 : READ_BOOL_FIELD(isDomain);
1029 1794 : READ_NODE_FIELD(overlapsExpr);
1030 1794 : READ_NODE_FIELD(rangeTargetList);
1031 1794 : READ_OID_FIELD(withoutPortionProc);
1032 1794 : READ_LOCATION_FIELD(location);
1033 1794 : READ_LOCATION_FIELD(targetLocation);
1034 :
1035 1794 : READ_DONE();
1036 : }
1037 :
1038 : static Query *
1039 671740 : _readQuery(void)
1040 : {
1041 671740 : READ_LOCALS(Query);
1042 :
1043 671740 : READ_ENUM_FIELD(commandType, CmdType);
1044 671740 : READ_ENUM_FIELD(querySource, QuerySource);
1045 671740 : local_node->queryId = 0;
1046 671740 : READ_BOOL_FIELD(canSetTag);
1047 671740 : READ_NODE_FIELD(utilityStmt);
1048 671740 : READ_INT_FIELD(resultRelation);
1049 671740 : READ_NODE_FIELD(forPortionOf);
1050 671740 : READ_BOOL_FIELD(hasAggs);
1051 671740 : READ_BOOL_FIELD(hasWindowFuncs);
1052 671740 : READ_BOOL_FIELD(hasTargetSRFs);
1053 671740 : READ_BOOL_FIELD(hasSubLinks);
1054 671740 : READ_BOOL_FIELD(hasDistinctOn);
1055 671740 : READ_BOOL_FIELD(hasRecursive);
1056 671740 : READ_BOOL_FIELD(hasModifyingCTE);
1057 671740 : READ_BOOL_FIELD(hasForUpdate);
1058 671740 : READ_BOOL_FIELD(hasRowSecurity);
1059 671740 : READ_BOOL_FIELD(hasGroupRTE);
1060 671740 : READ_BOOL_FIELD(isReturn);
1061 671740 : READ_NODE_FIELD(cteList);
1062 671740 : READ_NODE_FIELD(rtable);
1063 671740 : READ_NODE_FIELD(rteperminfos);
1064 671740 : READ_NODE_FIELD(jointree);
1065 671740 : READ_NODE_FIELD(mergeActionList);
1066 671740 : READ_INT_FIELD(mergeTargetRelation);
1067 671740 : READ_NODE_FIELD(mergeJoinCondition);
1068 671740 : READ_NODE_FIELD(targetList);
1069 671740 : READ_ENUM_FIELD(override, OverridingKind);
1070 671740 : READ_NODE_FIELD(onConflict);
1071 671740 : READ_STRING_FIELD(returningOldAlias);
1072 671740 : READ_STRING_FIELD(returningNewAlias);
1073 671740 : READ_NODE_FIELD(returningList);
1074 671740 : READ_NODE_FIELD(groupClause);
1075 671740 : READ_BOOL_FIELD(groupDistinct);
1076 671740 : READ_BOOL_FIELD(groupByAll);
1077 671740 : READ_NODE_FIELD(groupingSets);
1078 671740 : READ_NODE_FIELD(havingQual);
1079 671740 : READ_NODE_FIELD(windowClause);
1080 671740 : READ_NODE_FIELD(distinctClause);
1081 671740 : READ_NODE_FIELD(sortClause);
1082 671740 : READ_NODE_FIELD(limitOffset);
1083 671740 : READ_NODE_FIELD(limitCount);
1084 671740 : READ_ENUM_FIELD(limitOption, LimitOption);
1085 671740 : READ_NODE_FIELD(rowMarks);
1086 671740 : READ_NODE_FIELD(setOperations);
1087 671740 : READ_NODE_FIELD(constraintDeps);
1088 671740 : READ_NODE_FIELD(withCheckOptions);
1089 671740 : READ_LOCATION_FIELD(stmt_location);
1090 671740 : READ_LOCATION_FIELD(stmt_len);
1091 :
1092 671740 : READ_DONE();
1093 : }
1094 :
1095 : static TypeName *
1096 481100 : _readTypeName(void)
1097 : {
1098 481100 : READ_LOCALS(TypeName);
1099 :
1100 481100 : READ_NODE_FIELD(names);
1101 481100 : READ_OID_FIELD(typeOid);
1102 481100 : READ_BOOL_FIELD(setof);
1103 481100 : READ_BOOL_FIELD(pct_type);
1104 481100 : READ_NODE_FIELD(typmods);
1105 481100 : READ_INT_FIELD(typemod);
1106 481100 : READ_NODE_FIELD(arrayBounds);
1107 481100 : READ_LOCATION_FIELD(location);
1108 :
1109 481100 : READ_DONE();
1110 : }
1111 :
1112 : static ColumnRef *
1113 1382887 : _readColumnRef(void)
1114 : {
1115 1382887 : READ_LOCALS(ColumnRef);
1116 :
1117 1382887 : READ_NODE_FIELD(fields);
1118 1382887 : READ_LOCATION_FIELD(location);
1119 :
1120 1382887 : READ_DONE();
1121 : }
1122 :
1123 : static ParamRef *
1124 31434 : _readParamRef(void)
1125 : {
1126 31434 : READ_LOCALS(ParamRef);
1127 :
1128 31434 : READ_INT_FIELD(number);
1129 31434 : READ_LOCATION_FIELD(location);
1130 :
1131 31434 : READ_DONE();
1132 : }
1133 :
1134 : static TypeCast *
1135 237187 : _readTypeCast(void)
1136 : {
1137 237187 : READ_LOCALS(TypeCast);
1138 :
1139 237187 : READ_NODE_FIELD(arg);
1140 237187 : READ_NODE_FIELD(typeName);
1141 237187 : READ_LOCATION_FIELD(location);
1142 :
1143 237187 : READ_DONE();
1144 : }
1145 :
1146 : static CollateClause *
1147 7842 : _readCollateClause(void)
1148 : {
1149 7842 : READ_LOCALS(CollateClause);
1150 :
1151 7842 : READ_NODE_FIELD(arg);
1152 7842 : READ_NODE_FIELD(collname);
1153 7842 : READ_LOCATION_FIELD(location);
1154 :
1155 7842 : READ_DONE();
1156 : }
1157 :
1158 : static RoleSpec *
1159 28697 : _readRoleSpec(void)
1160 : {
1161 28697 : READ_LOCALS(RoleSpec);
1162 :
1163 28697 : READ_ENUM_FIELD(roletype, RoleSpecType);
1164 28697 : READ_STRING_FIELD(rolename);
1165 28697 : READ_LOCATION_FIELD(location);
1166 :
1167 28697 : READ_DONE();
1168 : }
1169 :
1170 : static FuncCall *
1171 272668 : _readFuncCall(void)
1172 : {
1173 272668 : READ_LOCALS(FuncCall);
1174 :
1175 272668 : READ_NODE_FIELD(funcname);
1176 272668 : READ_NODE_FIELD(args);
1177 272668 : READ_NODE_FIELD(agg_order);
1178 272668 : READ_NODE_FIELD(agg_filter);
1179 272668 : READ_NODE_FIELD(over);
1180 272668 : READ_INT_FIELD(ignore_nulls);
1181 272668 : READ_BOOL_FIELD(agg_within_group);
1182 272668 : READ_BOOL_FIELD(agg_star);
1183 272668 : READ_BOOL_FIELD(agg_distinct);
1184 272668 : READ_BOOL_FIELD(func_variadic);
1185 272668 : READ_ENUM_FIELD(funcformat, CoercionForm);
1186 272668 : READ_LOCATION_FIELD(location);
1187 :
1188 272668 : READ_DONE();
1189 : }
1190 :
1191 : static A_Star *
1192 46947 : _readA_Star(void)
1193 : {
1194 46947 : READ_LOCALS_NO_FIELDS(A_Star);
1195 :
1196 :
1197 46947 : READ_DONE();
1198 : }
1199 :
1200 : static A_Indices *
1201 10294 : _readA_Indices(void)
1202 : {
1203 10294 : READ_LOCALS(A_Indices);
1204 :
1205 10294 : READ_BOOL_FIELD(is_slice);
1206 10294 : READ_NODE_FIELD(lidx);
1207 10294 : READ_NODE_FIELD(uidx);
1208 :
1209 10294 : READ_DONE();
1210 : }
1211 :
1212 : static A_Indirection *
1213 25450 : _readA_Indirection(void)
1214 : {
1215 25450 : READ_LOCALS(A_Indirection);
1216 :
1217 25450 : READ_NODE_FIELD(arg);
1218 25450 : READ_NODE_FIELD(indirection);
1219 :
1220 25450 : READ_DONE();
1221 : }
1222 :
1223 : static A_ArrayExpr *
1224 5159 : _readA_ArrayExpr(void)
1225 : {
1226 5159 : READ_LOCALS(A_ArrayExpr);
1227 :
1228 5159 : READ_NODE_FIELD(elements);
1229 5159 : READ_LOCATION_FIELD(list_start);
1230 5159 : READ_LOCATION_FIELD(list_end);
1231 5159 : READ_LOCATION_FIELD(location);
1232 :
1233 5159 : READ_DONE();
1234 : }
1235 :
1236 : static ResTarget *
1237 863062 : _readResTarget(void)
1238 : {
1239 863062 : READ_LOCALS(ResTarget);
1240 :
1241 863062 : READ_STRING_FIELD(name);
1242 863062 : READ_NODE_FIELD(indirection);
1243 863062 : READ_NODE_FIELD(val);
1244 863062 : READ_LOCATION_FIELD(location);
1245 :
1246 863062 : 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 76948 : _readSortBy(void)
1263 : {
1264 76948 : READ_LOCALS(SortBy);
1265 :
1266 76948 : READ_NODE_FIELD(node);
1267 76948 : READ_ENUM_FIELD(sortby_dir, SortByDir);
1268 76948 : READ_ENUM_FIELD(sortby_nulls, SortByNulls);
1269 76948 : READ_NODE_FIELD(useOp);
1270 76948 : READ_LOCATION_FIELD(location);
1271 :
1272 76948 : READ_DONE();
1273 : }
1274 :
1275 : static WindowDef *
1276 3163 : _readWindowDef(void)
1277 : {
1278 3163 : READ_LOCALS(WindowDef);
1279 :
1280 3163 : READ_STRING_FIELD(name);
1281 3163 : READ_STRING_FIELD(refname);
1282 3163 : READ_NODE_FIELD(partitionClause);
1283 3163 : READ_NODE_FIELD(orderClause);
1284 3163 : READ_INT_FIELD(frameOptions);
1285 3163 : READ_NODE_FIELD(startOffset);
1286 3163 : READ_NODE_FIELD(endOffset);
1287 3163 : READ_LOCATION_FIELD(location);
1288 :
1289 3163 : READ_DONE();
1290 : }
1291 :
1292 : static RangeSubselect *
1293 16071 : _readRangeSubselect(void)
1294 : {
1295 16071 : READ_LOCALS(RangeSubselect);
1296 :
1297 16071 : READ_BOOL_FIELD(lateral);
1298 16071 : READ_NODE_FIELD(subquery);
1299 16071 : READ_NODE_FIELD(alias);
1300 :
1301 16071 : READ_DONE();
1302 : }
1303 :
1304 : static RangeFunction *
1305 33429 : _readRangeFunction(void)
1306 : {
1307 33429 : READ_LOCALS(RangeFunction);
1308 :
1309 33429 : READ_BOOL_FIELD(lateral);
1310 33429 : READ_BOOL_FIELD(ordinality);
1311 33429 : READ_BOOL_FIELD(is_rowsfrom);
1312 33429 : READ_NODE_FIELD(functions);
1313 33429 : READ_NODE_FIELD(alias);
1314 33429 : READ_NODE_FIELD(coldeflist);
1315 :
1316 33429 : 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 451 : _readRangeGraphTable(void)
1353 : {
1354 451 : READ_LOCALS(RangeGraphTable);
1355 :
1356 451 : READ_NODE_FIELD(graph_name);
1357 451 : READ_NODE_FIELD(graph_pattern);
1358 451 : READ_NODE_FIELD(columns);
1359 451 : READ_NODE_FIELD(alias);
1360 451 : READ_LOCATION_FIELD(location);
1361 :
1362 451 : 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 95281 : _readColumnDef(void)
1381 : {
1382 95281 : READ_LOCALS(ColumnDef);
1383 :
1384 95281 : READ_STRING_FIELD(colname);
1385 95281 : READ_NODE_FIELD(typeName);
1386 95281 : READ_STRING_FIELD(compression);
1387 95281 : READ_INT_FIELD(inhcount);
1388 95281 : READ_BOOL_FIELD(is_local);
1389 95281 : READ_BOOL_FIELD(is_not_null);
1390 95281 : READ_BOOL_FIELD(is_from_type);
1391 95281 : READ_CHAR_FIELD(storage);
1392 95281 : READ_STRING_FIELD(storage_name);
1393 95281 : READ_NODE_FIELD(raw_default);
1394 95281 : READ_NODE_FIELD(cooked_default);
1395 95281 : READ_CHAR_FIELD(identity);
1396 95281 : READ_NODE_FIELD(identitySequence);
1397 95281 : READ_CHAR_FIELD(generated);
1398 95281 : READ_NODE_FIELD(collClause);
1399 95281 : READ_OID_FIELD(collOid);
1400 95281 : READ_NODE_FIELD(constraints);
1401 95281 : READ_NODE_FIELD(fdwoptions);
1402 95281 : READ_LOCATION_FIELD(location);
1403 :
1404 95281 : 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 13207 : _readIndexElem(void)
1421 : {
1422 13207 : READ_LOCALS(IndexElem);
1423 :
1424 13207 : READ_STRING_FIELD(name);
1425 13207 : READ_NODE_FIELD(expr);
1426 13207 : READ_STRING_FIELD(indexcolname);
1427 13207 : READ_NODE_FIELD(collation);
1428 13207 : READ_NODE_FIELD(opclass);
1429 13207 : READ_NODE_FIELD(opclassopts);
1430 13207 : READ_ENUM_FIELD(ordering, SortByDir);
1431 13207 : READ_ENUM_FIELD(nulls_ordering, SortByNulls);
1432 13207 : READ_LOCATION_FIELD(location);
1433 :
1434 13207 : READ_DONE();
1435 : }
1436 :
1437 : static DefElem *
1438 430630 : _readDefElem(void)
1439 : {
1440 430630 : READ_LOCALS(DefElem);
1441 :
1442 430630 : READ_STRING_FIELD(defnamespace);
1443 430630 : READ_STRING_FIELD(defname);
1444 430630 : READ_NODE_FIELD(arg);
1445 430630 : READ_ENUM_FIELD(defaction, DefElemAction);
1446 430630 : READ_LOCATION_FIELD(location);
1447 :
1448 430630 : 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 7870 : _readPartitionElem(void)
1479 : {
1480 7870 : READ_LOCALS(PartitionElem);
1481 :
1482 7870 : READ_STRING_FIELD(name);
1483 7870 : READ_NODE_FIELD(expr);
1484 7870 : READ_NODE_FIELD(collation);
1485 7870 : READ_NODE_FIELD(opclass);
1486 7870 : READ_LOCATION_FIELD(location);
1487 :
1488 7870 : READ_DONE();
1489 : }
1490 :
1491 : static PartitionSpec *
1492 7226 : _readPartitionSpec(void)
1493 : {
1494 7226 : READ_LOCALS(PartitionSpec);
1495 :
1496 7226 : READ_ENUM_FIELD(strategy, PartitionStrategy);
1497 7226 : READ_NODE_FIELD(partParams);
1498 7226 : READ_LOCATION_FIELD(location);
1499 :
1500 7226 : READ_DONE();
1501 : }
1502 :
1503 : static PartitionBoundSpec *
1504 86955 : _readPartitionBoundSpec(void)
1505 : {
1506 86955 : READ_LOCALS(PartitionBoundSpec);
1507 :
1508 86955 : READ_CHAR_FIELD(strategy);
1509 86955 : READ_BOOL_FIELD(is_default);
1510 86955 : READ_INT_FIELD(modulus);
1511 86955 : READ_INT_FIELD(remainder);
1512 86955 : READ_NODE_FIELD(listdatums);
1513 86955 : READ_NODE_FIELD(lowerdatums);
1514 86955 : READ_NODE_FIELD(upperdatums);
1515 86955 : READ_LOCATION_FIELD(location);
1516 :
1517 86955 : READ_DONE();
1518 : }
1519 :
1520 : static PartitionRangeDatum *
1521 115938 : _readPartitionRangeDatum(void)
1522 : {
1523 115938 : READ_LOCALS(PartitionRangeDatum);
1524 :
1525 115938 : READ_ENUM_FIELD(kind, PartitionRangeDatumKind);
1526 115938 : READ_NODE_FIELD(value);
1527 115938 : READ_LOCATION_FIELD(location);
1528 :
1529 115938 : READ_DONE();
1530 : }
1531 :
1532 : static SinglePartitionSpec *
1533 1460 : _readSinglePartitionSpec(void)
1534 : {
1535 1460 : READ_LOCALS(SinglePartitionSpec);
1536 :
1537 1460 : READ_NODE_FIELD(name);
1538 1460 : READ_NODE_FIELD(bound);
1539 :
1540 1460 : READ_DONE();
1541 : }
1542 :
1543 : static PartitionCmd *
1544 5492 : _readPartitionCmd(void)
1545 : {
1546 5492 : READ_LOCALS(PartitionCmd);
1547 :
1548 5492 : READ_NODE_FIELD(name);
1549 5492 : READ_NODE_FIELD(bound);
1550 5492 : READ_NODE_FIELD(partlist);
1551 5492 : READ_BOOL_FIELD(concurrent);
1552 :
1553 5492 : READ_DONE();
1554 : }
1555 :
1556 : static GraphPattern *
1557 536 : _readGraphPattern(void)
1558 : {
1559 536 : READ_LOCALS(GraphPattern);
1560 :
1561 536 : READ_NODE_FIELD(path_pattern_list);
1562 536 : READ_NODE_FIELD(whereClause);
1563 :
1564 536 : READ_DONE();
1565 : }
1566 :
1567 : static GraphElementPattern *
1568 1590 : _readGraphElementPattern(void)
1569 : {
1570 1590 : READ_LOCALS(GraphElementPattern);
1571 :
1572 1590 : READ_ENUM_FIELD(kind, GraphElementPatternKind);
1573 1590 : READ_STRING_FIELD(variable);
1574 1590 : READ_NODE_FIELD(labelexpr);
1575 1590 : READ_NODE_FIELD(subexpr);
1576 1590 : READ_NODE_FIELD(whereClause);
1577 1590 : READ_NODE_FIELD(quantifier);
1578 1590 : READ_LOCATION_FIELD(location);
1579 :
1580 1590 : READ_DONE();
1581 : }
1582 :
1583 : static RTEPermissionInfo *
1584 731110 : _readRTEPermissionInfo(void)
1585 : {
1586 731110 : READ_LOCALS(RTEPermissionInfo);
1587 :
1588 731110 : READ_OID_FIELD(relid);
1589 731110 : READ_BOOL_FIELD(inh);
1590 731110 : READ_UINT64_FIELD(requiredPerms);
1591 731110 : READ_OID_FIELD(checkAsUser);
1592 731110 : READ_BITMAPSET_FIELD(selectedCols);
1593 731110 : READ_BITMAPSET_FIELD(insertedCols);
1594 731110 : READ_BITMAPSET_FIELD(updatedCols);
1595 :
1596 731110 : READ_DONE();
1597 : }
1598 :
1599 : static RangeTblFunction *
1600 70654 : _readRangeTblFunction(void)
1601 : {
1602 70654 : READ_LOCALS(RangeTblFunction);
1603 :
1604 70654 : READ_NODE_FIELD(funcexpr);
1605 70654 : READ_INT_FIELD(funccolcount);
1606 70654 : READ_NODE_FIELD(funccolnames);
1607 70654 : READ_NODE_FIELD(funccoltypes);
1608 70654 : READ_NODE_FIELD(funccoltypmods);
1609 70654 : READ_NODE_FIELD(funccolcollations);
1610 70654 : READ_BITMAPSET_FIELD(funcparams);
1611 :
1612 70654 : 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 116389 : _readSortGroupClause(void)
1643 : {
1644 116389 : READ_LOCALS(SortGroupClause);
1645 :
1646 116389 : READ_UINT_FIELD(tleSortGroupRef);
1647 116389 : READ_OID_FIELD(eqop);
1648 116389 : READ_OID_FIELD(sortop);
1649 116389 : READ_BOOL_FIELD(reverse_sort);
1650 116389 : READ_BOOL_FIELD(nulls_first);
1651 116389 : READ_BOOL_FIELD(hashable);
1652 :
1653 116389 : 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 2180 : _readWindowClause(void)
1670 : {
1671 2180 : READ_LOCALS(WindowClause);
1672 :
1673 2180 : READ_STRING_FIELD(name);
1674 2180 : READ_STRING_FIELD(refname);
1675 2180 : READ_NODE_FIELD(partitionClause);
1676 2180 : READ_NODE_FIELD(orderClause);
1677 2180 : READ_INT_FIELD(frameOptions);
1678 2180 : READ_NODE_FIELD(startOffset);
1679 2180 : READ_NODE_FIELD(endOffset);
1680 2180 : READ_OID_FIELD(startInRangeFunc);
1681 2180 : READ_OID_FIELD(endInRangeFunc);
1682 2180 : READ_OID_FIELD(inRangeColl);
1683 2180 : READ_BOOL_FIELD(inRangeAsc);
1684 2180 : READ_BOOL_FIELD(inRangeNullsFirst);
1685 2180 : READ_UINT_FIELD(winref);
1686 2180 : READ_BOOL_FIELD(copiedOrder);
1687 :
1688 2180 : READ_DONE();
1689 : }
1690 :
1691 : static RowMarkClause *
1692 5097 : _readRowMarkClause(void)
1693 : {
1694 5097 : READ_LOCALS(RowMarkClause);
1695 :
1696 5097 : READ_UINT_FIELD(rti);
1697 5097 : READ_ENUM_FIELD(strength, LockClauseStrength);
1698 5097 : READ_ENUM_FIELD(waitPolicy, LockWaitPolicy);
1699 5097 : READ_BOOL_FIELD(pushedDown);
1700 :
1701 5097 : READ_DONE();
1702 : }
1703 :
1704 : static ForPortionOfClause *
1705 993 : _readForPortionOfClause(void)
1706 : {
1707 993 : READ_LOCALS(ForPortionOfClause);
1708 :
1709 993 : READ_STRING_FIELD(range_name);
1710 993 : READ_LOCATION_FIELD(location);
1711 993 : READ_LOCATION_FIELD(target_location);
1712 993 : READ_NODE_FIELD(target);
1713 993 : READ_NODE_FIELD(target_start);
1714 993 : READ_NODE_FIELD(target_end);
1715 :
1716 993 : READ_DONE();
1717 : }
1718 :
1719 : static WithClause *
1720 2263 : _readWithClause(void)
1721 : {
1722 2263 : READ_LOCALS(WithClause);
1723 :
1724 2263 : READ_NODE_FIELD(ctes);
1725 2263 : READ_BOOL_FIELD(recursive);
1726 2263 : READ_LOCATION_FIELD(location);
1727 :
1728 2263 : READ_DONE();
1729 : }
1730 :
1731 : static InferClause *
1732 1420 : _readInferClause(void)
1733 : {
1734 1420 : READ_LOCALS(InferClause);
1735 :
1736 1420 : READ_NODE_FIELD(indexElems);
1737 1420 : READ_NODE_FIELD(whereClause);
1738 1420 : READ_STRING_FIELD(conname);
1739 1420 : READ_LOCATION_FIELD(location);
1740 :
1741 1420 : READ_DONE();
1742 : }
1743 :
1744 : static OnConflictClause *
1745 1576 : _readOnConflictClause(void)
1746 : {
1747 1576 : READ_LOCALS(OnConflictClause);
1748 :
1749 1576 : READ_ENUM_FIELD(action, OnConflictAction);
1750 1576 : READ_NODE_FIELD(infer);
1751 1576 : READ_ENUM_FIELD(lockStrength, LockClauseStrength);
1752 1576 : READ_NODE_FIELD(targetList);
1753 1576 : READ_NODE_FIELD(whereClause);
1754 1576 : READ_LOCATION_FIELD(location);
1755 :
1756 1576 : 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 5946 : _readCommonTableExpr(void)
1793 : {
1794 5946 : READ_LOCALS(CommonTableExpr);
1795 :
1796 5946 : READ_STRING_FIELD(ctename);
1797 5946 : READ_NODE_FIELD(aliascolnames);
1798 5946 : READ_ENUM_FIELD(ctematerialized, CTEMaterialize);
1799 5946 : READ_NODE_FIELD(ctequery);
1800 5946 : READ_NODE_FIELD(search_clause);
1801 5946 : READ_NODE_FIELD(cycle_clause);
1802 5946 : READ_LOCATION_FIELD(location);
1803 5946 : READ_BOOL_FIELD(cterecursive);
1804 5946 : READ_INT_FIELD(cterefcount);
1805 5946 : READ_NODE_FIELD(ctecolnames);
1806 5946 : READ_NODE_FIELD(ctecoltypes);
1807 5946 : READ_NODE_FIELD(ctecoltypmods);
1808 5946 : READ_NODE_FIELD(ctecolcollations);
1809 :
1810 5946 : READ_DONE();
1811 : }
1812 :
1813 : static MergeWhenClause *
1814 2042 : _readMergeWhenClause(void)
1815 : {
1816 2042 : READ_LOCALS(MergeWhenClause);
1817 :
1818 2042 : READ_ENUM_FIELD(matchKind, MergeMatchKind);
1819 2042 : READ_ENUM_FIELD(commandType, CmdType);
1820 2042 : READ_ENUM_FIELD(override, OverridingKind);
1821 2042 : READ_NODE_FIELD(condition);
1822 2042 : READ_NODE_FIELD(targetList);
1823 2042 : READ_NODE_FIELD(values);
1824 :
1825 2042 : 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 2476 : _readReturningClause(void)
1842 : {
1843 2476 : READ_LOCALS(ReturningClause);
1844 :
1845 2476 : READ_NODE_FIELD(options);
1846 2476 : READ_NODE_FIELD(exprs);
1847 :
1848 2476 : 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 1446 : _readJsonOutput(void)
1865 : {
1866 1446 : READ_LOCALS(JsonOutput);
1867 :
1868 1446 : READ_NODE_FIELD(typeName);
1869 1446 : READ_NODE_FIELD(returning);
1870 :
1871 1446 : 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 104 : _readJsonParseExpr(void)
1968 : {
1969 104 : READ_LOCALS(JsonParseExpr);
1970 :
1971 104 : READ_NODE_FIELD(expr);
1972 104 : READ_NODE_FIELD(output);
1973 104 : READ_BOOL_FIELD(unique_keys);
1974 104 : READ_LOCATION_FIELD(location);
1975 :
1976 104 : 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 92 : _readJsonArrayQueryConstructor(void)
2032 : {
2033 92 : READ_LOCALS(JsonArrayQueryConstructor);
2034 :
2035 92 : READ_NODE_FIELD(query);
2036 92 : READ_NODE_FIELD(output);
2037 92 : READ_NODE_FIELD(format);
2038 92 : READ_BOOL_FIELD(absent_on_null);
2039 92 : READ_LOCATION_FIELD(location);
2040 :
2041 92 : 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 471061 : _readRawStmt(void)
2085 : {
2086 471061 : READ_LOCALS(RawStmt);
2087 :
2088 471061 : READ_NODE_FIELD(stmt);
2089 471061 : READ_LOCATION_FIELD(stmt_location);
2090 471061 : READ_LOCATION_FIELD(stmt_len);
2091 :
2092 471061 : READ_DONE();
2093 : }
2094 :
2095 : static InsertStmt *
2096 44897 : _readInsertStmt(void)
2097 : {
2098 44897 : READ_LOCALS(InsertStmt);
2099 :
2100 44897 : READ_NODE_FIELD(relation);
2101 44897 : READ_NODE_FIELD(cols);
2102 44897 : READ_NODE_FIELD(selectStmt);
2103 44897 : READ_NODE_FIELD(onConflictClause);
2104 44897 : READ_NODE_FIELD(returningClause);
2105 44897 : READ_NODE_FIELD(withClause);
2106 44897 : READ_ENUM_FIELD(override, OverridingKind);
2107 :
2108 44897 : READ_DONE();
2109 : }
2110 :
2111 : static DeleteStmt *
2112 3334 : _readDeleteStmt(void)
2113 : {
2114 3334 : READ_LOCALS(DeleteStmt);
2115 :
2116 3334 : READ_NODE_FIELD(relation);
2117 3334 : READ_NODE_FIELD(usingClause);
2118 3334 : READ_NODE_FIELD(whereClause);
2119 3334 : READ_NODE_FIELD(returningClause);
2120 3334 : READ_NODE_FIELD(withClause);
2121 3334 : READ_NODE_FIELD(forPortionOf);
2122 :
2123 3334 : READ_DONE();
2124 : }
2125 :
2126 : static UpdateStmt *
2127 9119 : _readUpdateStmt(void)
2128 : {
2129 9119 : READ_LOCALS(UpdateStmt);
2130 :
2131 9119 : READ_NODE_FIELD(relation);
2132 9119 : READ_NODE_FIELD(targetList);
2133 9119 : READ_NODE_FIELD(whereClause);
2134 9119 : READ_NODE_FIELD(fromClause);
2135 9119 : READ_NODE_FIELD(returningClause);
2136 9119 : READ_NODE_FIELD(withClause);
2137 9119 : READ_NODE_FIELD(forPortionOf);
2138 :
2139 9119 : READ_DONE();
2140 : }
2141 :
2142 : static MergeStmt *
2143 1341 : _readMergeStmt(void)
2144 : {
2145 1341 : READ_LOCALS(MergeStmt);
2146 :
2147 1341 : READ_NODE_FIELD(relation);
2148 1341 : READ_NODE_FIELD(sourceRelation);
2149 1341 : READ_NODE_FIELD(joinCondition);
2150 1341 : READ_NODE_FIELD(mergeWhenClauses);
2151 1341 : READ_NODE_FIELD(returningClause);
2152 1341 : READ_NODE_FIELD(withClause);
2153 :
2154 1341 : READ_DONE();
2155 : }
2156 :
2157 : static SelectStmt *
2158 345570 : _readSelectStmt(void)
2159 : {
2160 345570 : READ_LOCALS(SelectStmt);
2161 :
2162 345570 : READ_NODE_FIELD(distinctClause);
2163 345570 : READ_NODE_FIELD(intoClause);
2164 345570 : READ_NODE_FIELD(targetList);
2165 345570 : READ_NODE_FIELD(fromClause);
2166 345570 : READ_NODE_FIELD(whereClause);
2167 345570 : READ_NODE_FIELD(groupClause);
2168 345570 : READ_BOOL_FIELD(groupDistinct);
2169 345570 : READ_BOOL_FIELD(groupByAll);
2170 345570 : READ_NODE_FIELD(havingClause);
2171 345570 : READ_NODE_FIELD(windowClause);
2172 345570 : READ_NODE_FIELD(valuesLists);
2173 345570 : READ_NODE_FIELD(sortClause);
2174 345570 : READ_NODE_FIELD(limitOffset);
2175 345570 : READ_NODE_FIELD(limitCount);
2176 345570 : READ_ENUM_FIELD(limitOption, LimitOption);
2177 345570 : READ_NODE_FIELD(lockingClause);
2178 345570 : READ_NODE_FIELD(withClause);
2179 345570 : READ_ENUM_FIELD(op, SetOperation);
2180 345570 : READ_BOOL_FIELD(all);
2181 345570 : READ_NODE_FIELD(larg);
2182 345570 : READ_NODE_FIELD(rarg);
2183 :
2184 345570 : READ_DONE();
2185 : }
2186 :
2187 : static SetOperationStmt *
2188 21310 : _readSetOperationStmt(void)
2189 : {
2190 21310 : READ_LOCALS(SetOperationStmt);
2191 :
2192 21310 : READ_ENUM_FIELD(op, SetOperation);
2193 21310 : READ_BOOL_FIELD(all);
2194 21310 : READ_NODE_FIELD(larg);
2195 21310 : READ_NODE_FIELD(rarg);
2196 21310 : READ_NODE_FIELD(colTypes);
2197 21310 : READ_NODE_FIELD(colTypmods);
2198 21310 : READ_NODE_FIELD(colCollations);
2199 21310 : READ_NODE_FIELD(groupClauses);
2200 :
2201 21310 : READ_DONE();
2202 : }
2203 :
2204 : static ReturnStmt *
2205 5492 : _readReturnStmt(void)
2206 : {
2207 5492 : READ_LOCALS(ReturnStmt);
2208 :
2209 5492 : READ_NODE_FIELD(returnval);
2210 :
2211 5492 : 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 1469 : _readCreateSchemaStmt(void)
2230 : {
2231 1469 : READ_LOCALS(CreateSchemaStmt);
2232 :
2233 1469 : READ_STRING_FIELD(schemaname);
2234 1469 : READ_NODE_FIELD(authrole);
2235 1469 : READ_NODE_FIELD(schemaElts);
2236 1469 : READ_BOOL_FIELD(if_not_exists);
2237 :
2238 1469 : READ_DONE();
2239 : }
2240 :
2241 : static AlterTableStmt *
2242 41008 : _readAlterTableStmt(void)
2243 : {
2244 41008 : READ_LOCALS(AlterTableStmt);
2245 :
2246 41008 : READ_NODE_FIELD(relation);
2247 41008 : READ_NODE_FIELD(cmds);
2248 41008 : READ_ENUM_FIELD(objtype, ObjectType);
2249 41008 : READ_BOOL_FIELD(missing_ok);
2250 :
2251 41008 : READ_DONE();
2252 : }
2253 :
2254 : static AlterTableCmd *
2255 42418 : _readAlterTableCmd(void)
2256 : {
2257 42418 : READ_LOCALS(AlterTableCmd);
2258 :
2259 42418 : READ_ENUM_FIELD(subtype, AlterTableType);
2260 42418 : READ_STRING_FIELD(name);
2261 42418 : READ_INT_FIELD(num);
2262 42418 : READ_NODE_FIELD(newowner);
2263 42418 : READ_NODE_FIELD(def);
2264 42418 : READ_ENUM_FIELD(behavior, DropBehavior);
2265 42418 : READ_BOOL_FIELD(missing_ok);
2266 42418 : READ_BOOL_FIELD(recurse);
2267 :
2268 42418 : READ_DONE();
2269 : }
2270 :
2271 : static ATAlterConstraint *
2272 592 : _readATAlterConstraint(void)
2273 : {
2274 592 : READ_LOCALS(ATAlterConstraint);
2275 :
2276 592 : READ_STRING_FIELD(conname);
2277 592 : READ_BOOL_FIELD(alterEnforceability);
2278 592 : READ_BOOL_FIELD(is_enforced);
2279 592 : READ_BOOL_FIELD(alterDeferrability);
2280 592 : READ_BOOL_FIELD(deferrable);
2281 592 : READ_BOOL_FIELD(initdeferred);
2282 592 : READ_BOOL_FIELD(alterInheritability);
2283 592 : READ_BOOL_FIELD(noinherit);
2284 :
2285 592 : READ_DONE();
2286 : }
2287 :
2288 : static ReplicaIdentityStmt *
2289 620 : _readReplicaIdentityStmt(void)
2290 : {
2291 620 : READ_LOCALS(ReplicaIdentityStmt);
2292 :
2293 620 : READ_CHAR_FIELD(identity_type);
2294 620 : READ_STRING_FIELD(name);
2295 :
2296 620 : 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 16963 : _readGrantStmt(void)
2326 : {
2327 16963 : READ_LOCALS(GrantStmt);
2328 :
2329 16963 : READ_BOOL_FIELD(is_grant);
2330 16963 : READ_ENUM_FIELD(targtype, GrantTargetType);
2331 16963 : READ_ENUM_FIELD(objtype, ObjectType);
2332 16963 : READ_NODE_FIELD(objects);
2333 16963 : READ_NODE_FIELD(privileges);
2334 16963 : READ_NODE_FIELD(grantees);
2335 16963 : READ_BOOL_FIELD(grant_option);
2336 16963 : READ_NODE_FIELD(grantor);
2337 16963 : READ_ENUM_FIELD(behavior, DropBehavior);
2338 :
2339 16963 : READ_DONE();
2340 : }
2341 :
2342 : static ObjectWithArgs *
2343 15924 : _readObjectWithArgs(void)
2344 : {
2345 15924 : READ_LOCALS(ObjectWithArgs);
2346 :
2347 15924 : READ_NODE_FIELD(objname);
2348 15924 : READ_NODE_FIELD(objargs);
2349 15924 : READ_NODE_FIELD(objfuncargs);
2350 15924 : READ_BOOL_FIELD(args_unspecified);
2351 :
2352 15924 : READ_DONE();
2353 : }
2354 :
2355 : static AccessPriv *
2356 15173 : _readAccessPriv(void)
2357 : {
2358 15173 : READ_LOCALS(AccessPriv);
2359 :
2360 15173 : READ_STRING_FIELD(priv_name);
2361 15173 : READ_NODE_FIELD(cols);
2362 :
2363 15173 : READ_DONE();
2364 : }
2365 :
2366 : static GrantRoleStmt *
2367 836 : _readGrantRoleStmt(void)
2368 : {
2369 836 : READ_LOCALS(GrantRoleStmt);
2370 :
2371 836 : READ_NODE_FIELD(granted_roles);
2372 836 : READ_NODE_FIELD(grantee_roles);
2373 836 : READ_BOOL_FIELD(is_grant);
2374 836 : READ_NODE_FIELD(opt);
2375 836 : READ_NODE_FIELD(grantor);
2376 836 : READ_ENUM_FIELD(behavior, DropBehavior);
2377 :
2378 836 : 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 13441 : _readCopyStmt(void)
2394 : {
2395 13441 : READ_LOCALS(CopyStmt);
2396 :
2397 13441 : READ_NODE_FIELD(relation);
2398 13441 : READ_NODE_FIELD(query);
2399 13441 : READ_NODE_FIELD(attlist);
2400 13441 : READ_BOOL_FIELD(is_from);
2401 13441 : READ_BOOL_FIELD(is_program);
2402 13441 : READ_STRING_FIELD(filename);
2403 13441 : READ_NODE_FIELD(options);
2404 13441 : READ_NODE_FIELD(whereClause);
2405 :
2406 13441 : READ_DONE();
2407 : }
2408 :
2409 : static VariableSetStmt *
2410 39461 : _readVariableSetStmt(void)
2411 : {
2412 39461 : READ_LOCALS(VariableSetStmt);
2413 :
2414 39461 : READ_ENUM_FIELD(kind, VariableSetKind);
2415 39461 : READ_STRING_FIELD(name);
2416 39461 : READ_NODE_FIELD(args);
2417 39461 : READ_BOOL_FIELD(jumble_args);
2418 39461 : READ_BOOL_FIELD(is_local);
2419 39461 : READ_LOCATION_FIELD(location);
2420 :
2421 39461 : READ_DONE();
2422 : }
2423 :
2424 : static VariableShowStmt *
2425 1158 : _readVariableShowStmt(void)
2426 : {
2427 1158 : READ_LOCALS(VariableShowStmt);
2428 :
2429 1158 : READ_STRING_FIELD(name);
2430 :
2431 1158 : READ_DONE();
2432 : }
2433 :
2434 : static CreateStmt *
2435 51744 : _readCreateStmt(void)
2436 : {
2437 51744 : READ_LOCALS(CreateStmt);
2438 :
2439 51744 : READ_NODE_FIELD(relation);
2440 51744 : READ_NODE_FIELD(tableElts);
2441 51744 : READ_NODE_FIELD(inhRelations);
2442 51744 : READ_NODE_FIELD(partbound);
2443 51744 : READ_NODE_FIELD(partspec);
2444 51744 : READ_NODE_FIELD(ofTypename);
2445 51744 : READ_NODE_FIELD(constraints);
2446 51744 : READ_NODE_FIELD(nnconstraints);
2447 51744 : READ_NODE_FIELD(options);
2448 51744 : READ_ENUM_FIELD(oncommit, OnCommitAction);
2449 51744 : READ_STRING_FIELD(tablespacename);
2450 51744 : READ_STRING_FIELD(accessMethod);
2451 51744 : READ_BOOL_FIELD(if_not_exists);
2452 :
2453 51744 : READ_DONE();
2454 : }
2455 :
2456 : static Constraint *
2457 47902 : _readConstraint(void)
2458 : {
2459 47902 : READ_LOCALS(Constraint);
2460 :
2461 47902 : READ_ENUM_FIELD(contype, ConstrType);
2462 47902 : READ_STRING_FIELD(conname);
2463 47902 : READ_BOOL_FIELD(deferrable);
2464 47902 : READ_BOOL_FIELD(initdeferred);
2465 47902 : READ_BOOL_FIELD(is_enforced);
2466 47902 : READ_BOOL_FIELD(skip_validation);
2467 47902 : READ_BOOL_FIELD(initially_valid);
2468 47902 : READ_BOOL_FIELD(is_no_inherit);
2469 47902 : READ_NODE_FIELD(raw_expr);
2470 47902 : READ_STRING_FIELD(cooked_expr);
2471 47902 : READ_CHAR_FIELD(generated_when);
2472 47902 : READ_CHAR_FIELD(generated_kind);
2473 47902 : READ_BOOL_FIELD(nulls_not_distinct);
2474 47902 : READ_NODE_FIELD(keys);
2475 47902 : READ_BOOL_FIELD(without_overlaps);
2476 47902 : READ_NODE_FIELD(including);
2477 47902 : READ_NODE_FIELD(exclusions);
2478 47902 : READ_NODE_FIELD(options);
2479 47902 : READ_STRING_FIELD(indexname);
2480 47902 : READ_STRING_FIELD(indexspace);
2481 47902 : READ_BOOL_FIELD(reset_default_tblspc);
2482 47902 : READ_STRING_FIELD(access_method);
2483 47902 : READ_NODE_FIELD(where_clause);
2484 47902 : READ_NODE_FIELD(pktable);
2485 47902 : READ_NODE_FIELD(fk_attrs);
2486 47902 : READ_NODE_FIELD(pk_attrs);
2487 47902 : READ_BOOL_FIELD(fk_with_period);
2488 47902 : READ_BOOL_FIELD(pk_with_period);
2489 47902 : READ_CHAR_FIELD(fk_matchtype);
2490 47902 : READ_CHAR_FIELD(fk_upd_action);
2491 47902 : READ_CHAR_FIELD(fk_del_action);
2492 47902 : READ_NODE_FIELD(fk_del_set_cols);
2493 47902 : READ_NODE_FIELD(old_conpfeqop);
2494 47902 : READ_OID_FIELD(old_pktable_oid);
2495 47902 : READ_LOCATION_FIELD(location);
2496 :
2497 47902 : READ_DONE();
2498 : }
2499 :
2500 : static CreateTableSpaceStmt *
2501 152 : _readCreateTableSpaceStmt(void)
2502 : {
2503 152 : READ_LOCALS(CreateTableSpaceStmt);
2504 :
2505 152 : READ_STRING_FIELD(tablespacename);
2506 152 : READ_NODE_FIELD(owner);
2507 152 : READ_STRING_FIELD(location);
2508 152 : READ_NODE_FIELD(options);
2509 :
2510 152 : READ_DONE();
2511 : }
2512 :
2513 : static DropTableSpaceStmt *
2514 72 : _readDropTableSpaceStmt(void)
2515 : {
2516 72 : READ_LOCALS(DropTableSpaceStmt);
2517 :
2518 72 : READ_STRING_FIELD(tablespacename);
2519 72 : READ_BOOL_FIELD(missing_ok);
2520 :
2521 72 : 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 40 : _readAlterTableMoveAllStmt(void)
2538 : {
2539 40 : READ_LOCALS(AlterTableMoveAllStmt);
2540 :
2541 40 : READ_STRING_FIELD(orig_tablespacename);
2542 40 : READ_ENUM_FIELD(objtype, ObjectType);
2543 40 : READ_NODE_FIELD(roles);
2544 40 : READ_STRING_FIELD(new_tablespacename);
2545 40 : READ_BOOL_FIELD(nowait);
2546 :
2547 40 : READ_DONE();
2548 : }
2549 :
2550 : static CreateExtensionStmt *
2551 632 : _readCreateExtensionStmt(void)
2552 : {
2553 632 : READ_LOCALS(CreateExtensionStmt);
2554 :
2555 632 : READ_STRING_FIELD(extname);
2556 632 : READ_BOOL_FIELD(if_not_exists);
2557 632 : READ_NODE_FIELD(options);
2558 :
2559 632 : 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 268 : _readCreateFdwStmt(void)
2588 : {
2589 268 : READ_LOCALS(CreateFdwStmt);
2590 :
2591 268 : READ_STRING_FIELD(fdwname);
2592 268 : READ_NODE_FIELD(func_options);
2593 268 : READ_NODE_FIELD(options);
2594 :
2595 268 : READ_DONE();
2596 : }
2597 :
2598 : static AlterFdwStmt *
2599 200 : _readAlterFdwStmt(void)
2600 : {
2601 200 : READ_LOCALS(AlterFdwStmt);
2602 :
2603 200 : READ_STRING_FIELD(fdwname);
2604 200 : READ_NODE_FIELD(func_options);
2605 200 : READ_NODE_FIELD(options);
2606 :
2607 200 : READ_DONE();
2608 : }
2609 :
2610 : static CreateForeignServerStmt *
2611 373 : _readCreateForeignServerStmt(void)
2612 : {
2613 373 : READ_LOCALS(CreateForeignServerStmt);
2614 :
2615 373 : READ_STRING_FIELD(servername);
2616 373 : READ_STRING_FIELD(servertype);
2617 373 : READ_STRING_FIELD(version);
2618 373 : READ_STRING_FIELD(fdwname);
2619 373 : READ_BOOL_FIELD(if_not_exists);
2620 373 : READ_NODE_FIELD(options);
2621 :
2622 373 : 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 562 : _readCreateForeignTableStmt(void)
2640 : {
2641 562 : READ_LOCALS(CreateForeignTableStmt);
2642 :
2643 562 : READ_NODE_FIELD(base.relation);
2644 562 : READ_NODE_FIELD(base.tableElts);
2645 562 : READ_NODE_FIELD(base.inhRelations);
2646 562 : READ_NODE_FIELD(base.partbound);
2647 562 : READ_NODE_FIELD(base.partspec);
2648 562 : READ_NODE_FIELD(base.ofTypename);
2649 562 : READ_NODE_FIELD(base.constraints);
2650 562 : READ_NODE_FIELD(base.nnconstraints);
2651 562 : READ_NODE_FIELD(base.options);
2652 562 : READ_ENUM_FIELD(base.oncommit, OnCommitAction);
2653 562 : READ_STRING_FIELD(base.tablespacename);
2654 562 : READ_STRING_FIELD(base.accessMethod);
2655 562 : READ_BOOL_FIELD(base.if_not_exists);
2656 562 : READ_STRING_FIELD(servername);
2657 562 : READ_NODE_FIELD(options);
2658 :
2659 562 : READ_DONE();
2660 : }
2661 :
2662 : static CreateUserMappingStmt *
2663 324 : _readCreateUserMappingStmt(void)
2664 : {
2665 324 : READ_LOCALS(CreateUserMappingStmt);
2666 :
2667 324 : READ_NODE_FIELD(user);
2668 324 : READ_STRING_FIELD(servername);
2669 324 : READ_BOOL_FIELD(if_not_exists);
2670 324 : READ_NODE_FIELD(options);
2671 :
2672 324 : READ_DONE();
2673 : }
2674 :
2675 : static AlterUserMappingStmt *
2676 140 : _readAlterUserMappingStmt(void)
2677 : {
2678 140 : READ_LOCALS(AlterUserMappingStmt);
2679 :
2680 140 : READ_NODE_FIELD(user);
2681 140 : READ_STRING_FIELD(servername);
2682 140 : READ_NODE_FIELD(options);
2683 :
2684 140 : READ_DONE();
2685 : }
2686 :
2687 : static DropUserMappingStmt *
2688 158 : _readDropUserMappingStmt(void)
2689 : {
2690 158 : READ_LOCALS(DropUserMappingStmt);
2691 :
2692 158 : READ_NODE_FIELD(user);
2693 158 : READ_STRING_FIELD(servername);
2694 158 : READ_BOOL_FIELD(missing_ok);
2695 :
2696 158 : 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 4256 : _readCreateTrigStmt(void)
2758 : {
2759 4256 : READ_LOCALS(CreateTrigStmt);
2760 :
2761 4256 : READ_BOOL_FIELD(replace);
2762 4256 : READ_BOOL_FIELD(isconstraint);
2763 4256 : READ_STRING_FIELD(trigname);
2764 4256 : READ_NODE_FIELD(relation);
2765 4256 : READ_NODE_FIELD(funcname);
2766 4256 : READ_NODE_FIELD(args);
2767 4256 : READ_BOOL_FIELD(row);
2768 4256 : READ_INT_FIELD(timing);
2769 4256 : READ_INT_FIELD(events);
2770 4256 : READ_NODE_FIELD(columns);
2771 4256 : READ_NODE_FIELD(whenClause);
2772 4256 : READ_NODE_FIELD(transitionRels);
2773 4256 : READ_BOOL_FIELD(deferrable);
2774 4256 : READ_BOOL_FIELD(initdeferred);
2775 4256 : READ_NODE_FIELD(constrrel);
2776 :
2777 4256 : READ_DONE();
2778 : }
2779 :
2780 : static CreateEventTrigStmt *
2781 256 : _readCreateEventTrigStmt(void)
2782 : {
2783 256 : READ_LOCALS(CreateEventTrigStmt);
2784 :
2785 256 : READ_STRING_FIELD(trigname);
2786 256 : READ_STRING_FIELD(eventname);
2787 256 : READ_NODE_FIELD(whenclause);
2788 256 : READ_NODE_FIELD(funcname);
2789 :
2790 256 : READ_DONE();
2791 : }
2792 :
2793 : static AlterEventTrigStmt *
2794 62 : _readAlterEventTrigStmt(void)
2795 : {
2796 62 : READ_LOCALS(AlterEventTrigStmt);
2797 :
2798 62 : READ_STRING_FIELD(trigname);
2799 62 : READ_CHAR_FIELD(tgenabled);
2800 :
2801 62 : 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 2576 : _readCreateRoleStmt(void)
2821 : {
2822 2576 : READ_LOCALS(CreateRoleStmt);
2823 :
2824 2576 : READ_ENUM_FIELD(stmt_type, RoleStmtType);
2825 2576 : READ_STRING_FIELD(role);
2826 2576 : READ_NODE_FIELD(options);
2827 :
2828 2576 : 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 102 : _readAlterRoleSetStmt(void)
2845 : {
2846 102 : READ_LOCALS(AlterRoleSetStmt);
2847 :
2848 102 : READ_NODE_FIELD(role);
2849 102 : READ_STRING_FIELD(database);
2850 102 : READ_NODE_FIELD(setstmt);
2851 :
2852 102 : READ_DONE();
2853 : }
2854 :
2855 : static DropRoleStmt *
2856 2442 : _readDropRoleStmt(void)
2857 : {
2858 2442 : READ_LOCALS(DropRoleStmt);
2859 :
2860 2442 : READ_NODE_FIELD(roles);
2861 2442 : READ_BOOL_FIELD(missing_ok);
2862 :
2863 2442 : READ_DONE();
2864 : }
2865 :
2866 : static CreateSeqStmt *
2867 884 : _readCreateSeqStmt(void)
2868 : {
2869 884 : READ_LOCALS(CreateSeqStmt);
2870 :
2871 884 : READ_NODE_FIELD(sequence);
2872 884 : READ_NODE_FIELD(options);
2873 884 : READ_OID_FIELD(ownerId);
2874 884 : READ_BOOL_FIELD(for_identity);
2875 884 : READ_BOOL_FIELD(if_not_exists);
2876 :
2877 884 : READ_DONE();
2878 : }
2879 :
2880 : static AlterSeqStmt *
2881 250 : _readAlterSeqStmt(void)
2882 : {
2883 250 : READ_LOCALS(AlterSeqStmt);
2884 :
2885 250 : READ_NODE_FIELD(sequence);
2886 250 : READ_NODE_FIELD(options);
2887 250 : READ_BOOL_FIELD(for_identity);
2888 250 : READ_BOOL_FIELD(missing_ok);
2889 :
2890 250 : READ_DONE();
2891 : }
2892 :
2893 : static DefineStmt *
2894 11282 : _readDefineStmt(void)
2895 : {
2896 11282 : READ_LOCALS(DefineStmt);
2897 :
2898 11282 : READ_ENUM_FIELD(kind, ObjectType);
2899 11282 : READ_BOOL_FIELD(oldstyle);
2900 11282 : READ_NODE_FIELD(defnames);
2901 11282 : READ_NODE_FIELD(args);
2902 11282 : READ_NODE_FIELD(definition);
2903 11282 : READ_BOOL_FIELD(if_not_exists);
2904 11282 : READ_BOOL_FIELD(replace);
2905 :
2906 11282 : READ_DONE();
2907 : }
2908 :
2909 : static CreateDomainStmt *
2910 1986 : _readCreateDomainStmt(void)
2911 : {
2912 1986 : READ_LOCALS(CreateDomainStmt);
2913 :
2914 1986 : READ_NODE_FIELD(domainname);
2915 1986 : READ_NODE_FIELD(typeName);
2916 1986 : READ_NODE_FIELD(collClause);
2917 1986 : READ_NODE_FIELD(constraints);
2918 :
2919 1986 : 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 34705 : _readDropStmt(void)
2978 : {
2979 34705 : READ_LOCALS(DropStmt);
2980 :
2981 34705 : READ_NODE_FIELD(objects);
2982 34705 : READ_ENUM_FIELD(removeType, ObjectType);
2983 34705 : READ_ENUM_FIELD(behavior, DropBehavior);
2984 34705 : READ_BOOL_FIELD(missing_ok);
2985 34705 : READ_BOOL_FIELD(concurrent);
2986 :
2987 34705 : READ_DONE();
2988 : }
2989 :
2990 : static TruncateStmt *
2991 2308 : _readTruncateStmt(void)
2992 : {
2993 2308 : READ_LOCALS(TruncateStmt);
2994 :
2995 2308 : READ_NODE_FIELD(relations);
2996 2308 : READ_BOOL_FIELD(restart_seqs);
2997 2308 : READ_ENUM_FIELD(behavior, DropBehavior);
2998 :
2999 2308 : 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 4312 : _readDeclareCursorStmt(void)
3029 : {
3030 4312 : READ_LOCALS(DeclareCursorStmt);
3031 :
3032 4312 : READ_STRING_FIELD(portalname);
3033 4312 : READ_INT_FIELD(options);
3034 4312 : READ_NODE_FIELD(query);
3035 :
3036 4312 : READ_DONE();
3037 : }
3038 :
3039 : static ClosePortalStmt *
3040 2356 : _readClosePortalStmt(void)
3041 : {
3042 2356 : READ_LOCALS(ClosePortalStmt);
3043 :
3044 2356 : READ_STRING_FIELD(portalname);
3045 :
3046 2356 : READ_DONE();
3047 : }
3048 :
3049 : static FetchStmt *
3050 7708 : _readFetchStmt(void)
3051 : {
3052 7708 : READ_LOCALS(FetchStmt);
3053 :
3054 7708 : READ_ENUM_FIELD(direction, FetchDirection);
3055 7708 : READ_LONG_FIELD(howMany);
3056 7708 : READ_STRING_FIELD(portalname);
3057 7708 : READ_BOOL_FIELD(ismove);
3058 7708 : READ_ENUM_FIELD(direction_keyword, FetchDirectionKeywords);
3059 7708 : READ_LOCATION_FIELD(location);
3060 :
3061 7708 : READ_DONE();
3062 : }
3063 :
3064 : static IndexStmt *
3065 8597 : _readIndexStmt(void)
3066 : {
3067 8597 : READ_LOCALS(IndexStmt);
3068 :
3069 8597 : READ_STRING_FIELD(idxname);
3070 8597 : READ_NODE_FIELD(relation);
3071 8597 : READ_STRING_FIELD(accessMethod);
3072 8597 : READ_STRING_FIELD(tableSpace);
3073 8597 : READ_NODE_FIELD(indexParams);
3074 8597 : READ_NODE_FIELD(indexIncludingParams);
3075 8597 : READ_NODE_FIELD(options);
3076 8597 : READ_NODE_FIELD(whereClause);
3077 8597 : READ_NODE_FIELD(excludeOpNames);
3078 8597 : READ_STRING_FIELD(idxcomment);
3079 8597 : READ_OID_FIELD(indexOid);
3080 8597 : READ_OID_FIELD(oldNumber);
3081 8597 : READ_UINT_FIELD(oldCreateSubid);
3082 8597 : READ_UINT_FIELD(oldFirstRelfilelocatorSubid);
3083 8597 : READ_BOOL_FIELD(unique);
3084 8597 : READ_BOOL_FIELD(nulls_not_distinct);
3085 8597 : READ_BOOL_FIELD(primary);
3086 8597 : READ_BOOL_FIELD(isconstraint);
3087 8597 : READ_BOOL_FIELD(iswithoutoverlaps);
3088 8597 : READ_BOOL_FIELD(deferrable);
3089 8597 : READ_BOOL_FIELD(initdeferred);
3090 8597 : READ_BOOL_FIELD(transformed);
3091 8597 : READ_BOOL_FIELD(concurrent);
3092 8597 : READ_BOOL_FIELD(if_not_exists);
3093 8597 : READ_BOOL_FIELD(reset_default_tblspc);
3094 :
3095 8597 : 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 25700 : _readCreateFunctionStmt(void)
3139 : {
3140 25700 : READ_LOCALS(CreateFunctionStmt);
3141 :
3142 25700 : READ_BOOL_FIELD(is_procedure);
3143 25700 : READ_BOOL_FIELD(replace);
3144 25700 : READ_NODE_FIELD(funcname);
3145 25700 : READ_NODE_FIELD(parameters);
3146 25700 : READ_NODE_FIELD(returnType);
3147 25700 : READ_NODE_FIELD(options);
3148 25700 : READ_NODE_FIELD(sql_body);
3149 :
3150 25700 : READ_DONE();
3151 : }
3152 :
3153 : static FunctionParameter *
3154 66841 : _readFunctionParameter(void)
3155 : {
3156 66841 : READ_LOCALS(FunctionParameter);
3157 :
3158 66841 : READ_STRING_FIELD(name);
3159 66841 : READ_NODE_FIELD(argType);
3160 66841 : READ_ENUM_FIELD(mode, FunctionParameterMode);
3161 66841 : READ_NODE_FIELD(defexpr);
3162 66841 : READ_LOCATION_FIELD(location);
3163 :
3164 66841 : READ_DONE();
3165 : }
3166 :
3167 : static AlterFunctionStmt *
3168 416 : _readAlterFunctionStmt(void)
3169 : {
3170 416 : READ_LOCALS(AlterFunctionStmt);
3171 :
3172 416 : READ_ENUM_FIELD(objtype, ObjectType);
3173 416 : READ_NODE_FIELD(func);
3174 416 : READ_NODE_FIELD(actions);
3175 :
3176 416 : READ_DONE();
3177 : }
3178 :
3179 : static DoStmt *
3180 1292 : _readDoStmt(void)
3181 : {
3182 1292 : READ_LOCALS(DoStmt);
3183 :
3184 1292 : READ_NODE_FIELD(args);
3185 :
3186 1292 : READ_DONE();
3187 : }
3188 :
3189 : static CallStmt *
3190 544 : _readCallStmt(void)
3191 : {
3192 544 : READ_LOCALS(CallStmt);
3193 :
3194 544 : READ_NODE_FIELD(funccall);
3195 544 : READ_NODE_FIELD(funcexpr);
3196 544 : READ_NODE_FIELD(outargs);
3197 :
3198 544 : READ_DONE();
3199 : }
3200 :
3201 : static RenameStmt *
3202 1908 : _readRenameStmt(void)
3203 : {
3204 1908 : READ_LOCALS(RenameStmt);
3205 :
3206 1908 : READ_ENUM_FIELD(renameType, ObjectType);
3207 1908 : READ_ENUM_FIELD(relationType, ObjectType);
3208 1908 : READ_NODE_FIELD(relation);
3209 1908 : READ_NODE_FIELD(object);
3210 1908 : READ_STRING_FIELD(subname);
3211 1908 : READ_STRING_FIELD(newname);
3212 1908 : READ_ENUM_FIELD(behavior, DropBehavior);
3213 1908 : READ_BOOL_FIELD(missing_ok);
3214 :
3215 1908 : 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 562 : _readAlterObjectSchemaStmt(void)
3234 : {
3235 562 : READ_LOCALS(AlterObjectSchemaStmt);
3236 :
3237 562 : READ_ENUM_FIELD(objectType, ObjectType);
3238 562 : READ_NODE_FIELD(relation);
3239 562 : READ_NODE_FIELD(object);
3240 562 : READ_STRING_FIELD(newschema);
3241 562 : READ_BOOL_FIELD(missing_ok);
3242 :
3243 562 : 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 120 : _readListenStmt(void)
3310 : {
3311 120 : READ_LOCALS(ListenStmt);
3312 :
3313 120 : READ_STRING_FIELD(conditionname);
3314 :
3315 120 : READ_DONE();
3316 : }
3317 :
3318 : static UnlistenStmt *
3319 160 : _readUnlistenStmt(void)
3320 : {
3321 160 : READ_LOCALS(UnlistenStmt);
3322 :
3323 160 : READ_STRING_FIELD(conditionname);
3324 :
3325 160 : READ_DONE();
3326 : }
3327 :
3328 : static TransactionStmt *
3329 54040 : _readTransactionStmt(void)
3330 : {
3331 54040 : READ_LOCALS(TransactionStmt);
3332 :
3333 54040 : READ_ENUM_FIELD(kind, TransactionStmtKind);
3334 54040 : READ_NODE_FIELD(options);
3335 54040 : READ_STRING_FIELD(savepoint_name);
3336 54040 : READ_STRING_FIELD(gid);
3337 54040 : READ_BOOL_FIELD(chain);
3338 54040 : READ_LOCATION_FIELD(location);
3339 :
3340 54040 : READ_DONE();
3341 : }
3342 :
3343 : static CompositeTypeStmt *
3344 2838 : _readCompositeTypeStmt(void)
3345 : {
3346 2838 : READ_LOCALS(CompositeTypeStmt);
3347 :
3348 2838 : READ_NODE_FIELD(typevar);
3349 2838 : READ_NODE_FIELD(coldeflist);
3350 :
3351 2838 : READ_DONE();
3352 : }
3353 :
3354 : static CreateEnumStmt *
3355 264 : _readCreateEnumStmt(void)
3356 : {
3357 264 : READ_LOCALS(CreateEnumStmt);
3358 :
3359 264 : READ_NODE_FIELD(typeName);
3360 264 : READ_NODE_FIELD(vals);
3361 :
3362 264 : READ_DONE();
3363 : }
3364 :
3365 : static CreateRangeStmt *
3366 284 : _readCreateRangeStmt(void)
3367 : {
3368 284 : READ_LOCALS(CreateRangeStmt);
3369 :
3370 284 : READ_NODE_FIELD(typeName);
3371 284 : READ_NODE_FIELD(params);
3372 :
3373 284 : 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 21857 : _readViewStmt(void)
3393 : {
3394 21857 : READ_LOCALS(ViewStmt);
3395 :
3396 21857 : READ_NODE_FIELD(view);
3397 21857 : READ_NODE_FIELD(aliases);
3398 21857 : READ_NODE_FIELD(query);
3399 21857 : READ_BOOL_FIELD(replace);
3400 21857 : READ_NODE_FIELD(options);
3401 21857 : READ_ENUM_FIELD(withCheckOption, ViewCheckOption);
3402 :
3403 21857 : 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 894 : _readCreatedbStmt(void)
3418 : {
3419 894 : READ_LOCALS(CreatedbStmt);
3420 :
3421 894 : READ_STRING_FIELD(dbname);
3422 894 : READ_NODE_FIELD(options);
3423 :
3424 894 : 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 150 : _readDropdbStmt(void)
3461 : {
3462 150 : READ_LOCALS(DropdbStmt);
3463 :
3464 150 : READ_STRING_FIELD(dbname);
3465 150 : READ_BOOL_FIELD(missing_ok);
3466 150 : READ_NODE_FIELD(options);
3467 :
3468 150 : READ_DONE();
3469 : }
3470 :
3471 : static AlterSystemStmt *
3472 234 : _readAlterSystemStmt(void)
3473 : {
3474 234 : READ_LOCALS(AlterSystemStmt);
3475 :
3476 234 : READ_NODE_FIELD(setstmt);
3477 :
3478 234 : READ_DONE();
3479 : }
3480 :
3481 : static VacuumStmt *
3482 17342 : _readVacuumStmt(void)
3483 : {
3484 17342 : READ_LOCALS(VacuumStmt);
3485 :
3486 17342 : READ_NODE_FIELD(options);
3487 17342 : READ_NODE_FIELD(rels);
3488 17342 : READ_BOOL_FIELD(is_vacuumcmd);
3489 :
3490 17342 : READ_DONE();
3491 : }
3492 :
3493 : static VacuumRelation *
3494 17572 : _readVacuumRelation(void)
3495 : {
3496 17572 : READ_LOCALS(VacuumRelation);
3497 :
3498 17572 : READ_NODE_FIELD(relation);
3499 17572 : READ_OID_FIELD(oid);
3500 17572 : READ_NODE_FIELD(va_cols);
3501 :
3502 17572 : READ_DONE();
3503 : }
3504 :
3505 : static RepackStmt *
3506 440 : _readRepackStmt(void)
3507 : {
3508 440 : READ_LOCALS(RepackStmt);
3509 :
3510 440 : READ_ENUM_FIELD(command, RepackCommand);
3511 440 : READ_NODE_FIELD(relation);
3512 440 : READ_STRING_FIELD(indexname);
3513 440 : READ_BOOL_FIELD(usingindex);
3514 440 : READ_NODE_FIELD(params);
3515 :
3516 440 : READ_DONE();
3517 : }
3518 :
3519 : static ExplainStmt *
3520 27377 : _readExplainStmt(void)
3521 : {
3522 27377 : READ_LOCALS(ExplainStmt);
3523 :
3524 27377 : READ_NODE_FIELD(query);
3525 27377 : READ_NODE_FIELD(options);
3526 :
3527 27377 : READ_DONE();
3528 : }
3529 :
3530 : static CreateTableAsStmt *
3531 2482 : _readCreateTableAsStmt(void)
3532 : {
3533 2482 : READ_LOCALS(CreateTableAsStmt);
3534 :
3535 2482 : READ_NODE_FIELD(query);
3536 2482 : READ_NODE_FIELD(into);
3537 2482 : READ_ENUM_FIELD(objtype, ObjectType);
3538 2482 : READ_BOOL_FIELD(is_select_into);
3539 2482 : READ_BOOL_FIELD(if_not_exists);
3540 :
3541 2482 : 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 289 : _readCheckPointStmt(void)
3558 : {
3559 289 : READ_LOCALS(CheckPointStmt);
3560 :
3561 289 : READ_NODE_FIELD(options);
3562 :
3563 289 : 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 1292 : _readLockStmt(void)
3578 : {
3579 1292 : READ_LOCALS(LockStmt);
3580 :
3581 1292 : READ_NODE_FIELD(relations);
3582 1292 : READ_INT_FIELD(mode);
3583 1292 : READ_BOOL_FIELD(nowait);
3584 :
3585 1292 : 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 1414 : _readReindexStmt(void)
3601 : {
3602 1414 : READ_LOCALS(ReindexStmt);
3603 :
3604 1414 : READ_ENUM_FIELD(kind, ReindexObjectType);
3605 1414 : READ_NODE_FIELD(relation);
3606 1414 : READ_STRING_FIELD(name);
3607 1414 : READ_NODE_FIELD(params);
3608 :
3609 1414 : 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 324 : _readCreateCastStmt(void)
3628 : {
3629 324 : READ_LOCALS(CreateCastStmt);
3630 :
3631 324 : READ_NODE_FIELD(sourcetype);
3632 324 : READ_NODE_FIELD(targettype);
3633 324 : READ_NODE_FIELD(func);
3634 324 : READ_ENUM_FIELD(context, CoercionContext);
3635 324 : READ_BOOL_FIELD(inout);
3636 :
3637 324 : READ_DONE();
3638 : }
3639 :
3640 : static CreatePropGraphStmt *
3641 402 : _readCreatePropGraphStmt(void)
3642 : {
3643 402 : READ_LOCALS(CreatePropGraphStmt);
3644 :
3645 402 : READ_NODE_FIELD(pgname);
3646 402 : READ_NODE_FIELD(vertex_tables);
3647 402 : READ_NODE_FIELD(edge_tables);
3648 :
3649 402 : READ_DONE();
3650 : }
3651 :
3652 : static PropGraphVertex *
3653 796 : _readPropGraphVertex(void)
3654 : {
3655 796 : READ_LOCALS(PropGraphVertex);
3656 :
3657 796 : READ_NODE_FIELD(vtable);
3658 796 : READ_NODE_FIELD(vkey);
3659 796 : READ_NODE_FIELD(labels);
3660 796 : READ_LOCATION_FIELD(location);
3661 :
3662 796 : READ_DONE();
3663 : }
3664 :
3665 : static PropGraphEdge *
3666 426 : _readPropGraphEdge(void)
3667 : {
3668 426 : READ_LOCALS(PropGraphEdge);
3669 :
3670 426 : READ_NODE_FIELD(etable);
3671 426 : READ_NODE_FIELD(ekey);
3672 426 : READ_NODE_FIELD(esrckey);
3673 426 : READ_STRING_FIELD(esrcvertex);
3674 426 : READ_NODE_FIELD(esrcvertexcols);
3675 426 : READ_NODE_FIELD(edestkey);
3676 426 : READ_STRING_FIELD(edestvertex);
3677 426 : READ_NODE_FIELD(edestvertexcols);
3678 426 : READ_NODE_FIELD(labels);
3679 426 : READ_LOCATION_FIELD(location);
3680 :
3681 426 : READ_DONE();
3682 : }
3683 :
3684 : static PropGraphLabelAndProperties *
3685 1510 : _readPropGraphLabelAndProperties(void)
3686 : {
3687 1510 : READ_LOCALS(PropGraphLabelAndProperties);
3688 :
3689 1510 : READ_STRING_FIELD(label);
3690 1510 : READ_NODE_FIELD(properties);
3691 1510 : READ_LOCATION_FIELD(location);
3692 :
3693 1510 : READ_DONE();
3694 : }
3695 :
3696 : static PropGraphProperties *
3697 1526 : _readPropGraphProperties(void)
3698 : {
3699 1526 : READ_LOCALS(PropGraphProperties);
3700 :
3701 1526 : READ_NODE_FIELD(properties);
3702 1526 : READ_BOOL_FIELD(all);
3703 1526 : READ_LOCATION_FIELD(location);
3704 :
3705 1526 : READ_DONE();
3706 : }
3707 :
3708 : static AlterPropGraphStmt *
3709 248 : _readAlterPropGraphStmt(void)
3710 : {
3711 248 : READ_LOCALS(AlterPropGraphStmt);
3712 :
3713 248 : READ_NODE_FIELD(pgname);
3714 248 : READ_BOOL_FIELD(missing_ok);
3715 248 : READ_NODE_FIELD(add_vertex_tables);
3716 248 : READ_NODE_FIELD(add_edge_tables);
3717 248 : READ_NODE_FIELD(drop_vertex_tables);
3718 248 : READ_NODE_FIELD(drop_edge_tables);
3719 248 : READ_ENUM_FIELD(drop_behavior, DropBehavior);
3720 248 : READ_ENUM_FIELD(element_kind, AlterPropGraphElementKind);
3721 248 : READ_STRING_FIELD(element_alias);
3722 248 : READ_NODE_FIELD(add_labels);
3723 248 : READ_STRING_FIELD(drop_label);
3724 248 : READ_STRING_FIELD(alter_label);
3725 248 : READ_NODE_FIELD(add_properties);
3726 248 : READ_NODE_FIELD(drop_properties);
3727 :
3728 248 : 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 2370 : _readPrepareStmt(void)
3747 : {
3748 2370 : READ_LOCALS(PrepareStmt);
3749 :
3750 2370 : READ_STRING_FIELD(name);
3751 2370 : READ_NODE_FIELD(argtypes);
3752 2370 : READ_NODE_FIELD(query);
3753 :
3754 2370 : READ_DONE();
3755 : }
3756 :
3757 : static ExecuteStmt *
3758 18010 : _readExecuteStmt(void)
3759 : {
3760 18010 : READ_LOCALS(ExecuteStmt);
3761 :
3762 18010 : READ_STRING_FIELD(name);
3763 18010 : READ_NODE_FIELD(params);
3764 :
3765 18010 : 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 2042 : _readPublicationTable(void)
3831 : {
3832 2042 : READ_LOCALS(PublicationTable);
3833 :
3834 2042 : READ_NODE_FIELD(relation);
3835 2042 : READ_NODE_FIELD(whereClause);
3836 2042 : READ_NODE_FIELD(columns);
3837 2042 : READ_BOOL_FIELD(except);
3838 :
3839 2042 : READ_DONE();
3840 : }
3841 :
3842 : static PublicationObjSpec *
3843 2570 : _readPublicationObjSpec(void)
3844 : {
3845 2570 : READ_LOCALS(PublicationObjSpec);
3846 :
3847 2570 : READ_ENUM_FIELD(pubobjtype, PublicationObjSpecType);
3848 2570 : READ_STRING_FIELD(name);
3849 2570 : READ_NODE_FIELD(pubtable);
3850 2570 : READ_LOCATION_FIELD(location);
3851 :
3852 2570 : 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 1262 : _readCreatePublicationStmt(void)
3869 : {
3870 1262 : READ_LOCALS(CreatePublicationStmt);
3871 :
3872 1262 : READ_STRING_FIELD(pubname);
3873 1262 : READ_NODE_FIELD(options);
3874 1262 : READ_NODE_FIELD(pubobjects);
3875 1262 : READ_BOOL_FIELD(for_all_tables);
3876 1262 : READ_BOOL_FIELD(for_all_sequences);
3877 :
3878 1262 : 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 608 : _readCreateSubscriptionStmt(void)
3898 : {
3899 608 : READ_LOCALS(CreateSubscriptionStmt);
3900 :
3901 608 : READ_STRING_FIELD(subname);
3902 608 : READ_STRING_FIELD(servername);
3903 608 : READ_STRING_FIELD(conninfo);
3904 608 : READ_NODE_FIELD(publication);
3905 608 : READ_NODE_FIELD(options);
3906 :
3907 608 : READ_DONE();
3908 : }
3909 :
3910 : static AlterSubscriptionStmt *
3911 687 : _readAlterSubscriptionStmt(void)
3912 : {
3913 687 : READ_LOCALS(AlterSubscriptionStmt);
3914 :
3915 687 : READ_ENUM_FIELD(kind, AlterSubscriptionType);
3916 687 : READ_STRING_FIELD(subname);
3917 687 : READ_STRING_FIELD(servername);
3918 687 : READ_STRING_FIELD(conninfo);
3919 687 : READ_NODE_FIELD(publication);
3920 687 : READ_NODE_FIELD(options);
3921 :
3922 687 : READ_DONE();
3923 : }
3924 :
3925 : static DropSubscriptionStmt *
3926 310 : _readDropSubscriptionStmt(void)
3927 : {
3928 310 : READ_LOCALS(DropSubscriptionStmt);
3929 :
3930 310 : READ_STRING_FIELD(subname);
3931 310 : READ_BOOL_FIELD(missing_ok);
3932 310 : READ_ENUM_FIELD(behavior, DropBehavior);
3933 :
3934 310 : READ_DONE();
3935 : }
3936 :
3937 : static WaitStmt *
3938 453 : _readWaitStmt(void)
3939 : {
3940 453 : READ_LOCALS(WaitStmt);
3941 :
3942 453 : READ_STRING_FIELD(lsn_literal);
3943 453 : READ_NODE_FIELD(options);
3944 :
3945 453 : 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 40240 : _readAppendRelInfo(void)
3975 : {
3976 40240 : READ_LOCALS(AppendRelInfo);
3977 :
3978 40240 : READ_UINT_FIELD(parent_relid);
3979 40240 : READ_UINT_FIELD(child_relid);
3980 40240 : READ_OID_FIELD(parent_reltype);
3981 40240 : READ_OID_FIELD(child_reltype);
3982 40240 : READ_NODE_FIELD(translated_vars);
3983 40240 : READ_INT_FIELD(num_child_cols);
3984 40240 : READ_ATTRNUMBER_ARRAY(parent_colnos, local_node->num_child_cols);
3985 40240 : READ_OID_FIELD(parent_reloid);
3986 :
3987 40240 : READ_DONE();
3988 : }
3989 :
3990 : static PlannedStmt *
3991 291772 : _readPlannedStmt(void)
3992 : {
3993 291772 : READ_LOCALS(PlannedStmt);
3994 :
3995 291772 : READ_ENUM_FIELD(commandType, CmdType);
3996 291772 : READ_INT64_FIELD(queryId);
3997 291772 : READ_INT64_FIELD(planId);
3998 291772 : READ_ENUM_FIELD(planOrigin, PlannedStmtOrigin);
3999 291772 : READ_BOOL_FIELD(hasReturning);
4000 291772 : READ_BOOL_FIELD(hasModifyingCTE);
4001 291772 : READ_BOOL_FIELD(canSetTag);
4002 291772 : READ_BOOL_FIELD(transientPlan);
4003 291772 : READ_BOOL_FIELD(dependsOnRole);
4004 291772 : READ_BOOL_FIELD(parallelModeNeeded);
4005 291772 : READ_INT_FIELD(jitFlags);
4006 291772 : READ_NODE_FIELD(planTree);
4007 291772 : READ_NODE_FIELD(partPruneInfos);
4008 291772 : READ_NODE_FIELD(rtable);
4009 291772 : READ_BITMAPSET_FIELD(unprunableRelids);
4010 291772 : READ_NODE_FIELD(permInfos);
4011 291772 : READ_BITMAPSET_FIELD(resultRelationRelids);
4012 291772 : READ_NODE_FIELD(appendRelations);
4013 291772 : READ_NODE_FIELD(subplans);
4014 291772 : READ_NODE_FIELD(subrtinfos);
4015 291772 : READ_BITMAPSET_FIELD(rewindPlanIDs);
4016 291772 : READ_NODE_FIELD(rowMarks);
4017 291772 : READ_BITMAPSET_FIELD(rowMarkRelids);
4018 291772 : READ_NODE_FIELD(relationOids);
4019 291772 : READ_NODE_FIELD(invalItems);
4020 291772 : READ_NODE_FIELD(paramExecTypes);
4021 291772 : READ_NODE_FIELD(utilityStmt);
4022 291772 : READ_NODE_FIELD(elidedNodes);
4023 291772 : READ_NODE_FIELD(extension_state);
4024 291772 : READ_LOCATION_FIELD(stmt_location);
4025 291772 : READ_LOCATION_FIELD(stmt_len);
4026 :
4027 291772 : READ_DONE();
4028 : }
4029 :
4030 : static Result *
4031 134549 : _readResult(void)
4032 : {
4033 134549 : READ_LOCALS(Result);
4034 :
4035 134549 : READ_INT_FIELD(plan.disabled_nodes);
4036 134549 : READ_FLOAT_FIELD(plan.startup_cost);
4037 134549 : READ_FLOAT_FIELD(plan.total_cost);
4038 134549 : READ_FLOAT_FIELD(plan.plan_rows);
4039 134549 : READ_INT_FIELD(plan.plan_width);
4040 134549 : READ_BOOL_FIELD(plan.parallel_aware);
4041 134549 : READ_BOOL_FIELD(plan.parallel_safe);
4042 134549 : READ_BOOL_FIELD(plan.async_capable);
4043 134549 : READ_INT_FIELD(plan.plan_node_id);
4044 134549 : READ_NODE_FIELD(plan.targetlist);
4045 134549 : READ_NODE_FIELD(plan.qual);
4046 134549 : READ_NODE_FIELD(plan.lefttree);
4047 134549 : READ_NODE_FIELD(plan.righttree);
4048 134549 : READ_NODE_FIELD(plan.initPlan);
4049 134549 : READ_BITMAPSET_FIELD(plan.extParam);
4050 134549 : READ_BITMAPSET_FIELD(plan.allParam);
4051 134549 : READ_ENUM_FIELD(result_type, ResultType);
4052 134549 : READ_NODE_FIELD(resconstantqual);
4053 134549 : READ_BITMAPSET_FIELD(relids);
4054 :
4055 134549 : READ_DONE();
4056 : }
4057 :
4058 : static ProjectSet *
4059 8624 : _readProjectSet(void)
4060 : {
4061 8624 : READ_LOCALS(ProjectSet);
4062 :
4063 8624 : READ_INT_FIELD(plan.disabled_nodes);
4064 8624 : READ_FLOAT_FIELD(plan.startup_cost);
4065 8624 : READ_FLOAT_FIELD(plan.total_cost);
4066 8624 : READ_FLOAT_FIELD(plan.plan_rows);
4067 8624 : READ_INT_FIELD(plan.plan_width);
4068 8624 : READ_BOOL_FIELD(plan.parallel_aware);
4069 8624 : READ_BOOL_FIELD(plan.parallel_safe);
4070 8624 : READ_BOOL_FIELD(plan.async_capable);
4071 8624 : READ_INT_FIELD(plan.plan_node_id);
4072 8624 : READ_NODE_FIELD(plan.targetlist);
4073 8624 : READ_NODE_FIELD(plan.qual);
4074 8624 : READ_NODE_FIELD(plan.lefttree);
4075 8624 : READ_NODE_FIELD(plan.righttree);
4076 8624 : READ_NODE_FIELD(plan.initPlan);
4077 8624 : READ_BITMAPSET_FIELD(plan.extParam);
4078 8624 : READ_BITMAPSET_FIELD(plan.allParam);
4079 :
4080 8624 : READ_DONE();
4081 : }
4082 :
4083 : static ModifyTable *
4084 57319 : _readModifyTable(void)
4085 : {
4086 57319 : READ_LOCALS(ModifyTable);
4087 :
4088 57319 : READ_INT_FIELD(plan.disabled_nodes);
4089 57319 : READ_FLOAT_FIELD(plan.startup_cost);
4090 57319 : READ_FLOAT_FIELD(plan.total_cost);
4091 57319 : READ_FLOAT_FIELD(plan.plan_rows);
4092 57319 : READ_INT_FIELD(plan.plan_width);
4093 57319 : READ_BOOL_FIELD(plan.parallel_aware);
4094 57319 : READ_BOOL_FIELD(plan.parallel_safe);
4095 57319 : READ_BOOL_FIELD(plan.async_capable);
4096 57319 : READ_INT_FIELD(plan.plan_node_id);
4097 57319 : READ_NODE_FIELD(plan.targetlist);
4098 57319 : READ_NODE_FIELD(plan.qual);
4099 57319 : READ_NODE_FIELD(plan.lefttree);
4100 57319 : READ_NODE_FIELD(plan.righttree);
4101 57319 : READ_NODE_FIELD(plan.initPlan);
4102 57319 : READ_BITMAPSET_FIELD(plan.extParam);
4103 57319 : READ_BITMAPSET_FIELD(plan.allParam);
4104 57319 : READ_ENUM_FIELD(operation, CmdType);
4105 57319 : READ_BOOL_FIELD(canSetTag);
4106 57319 : READ_UINT_FIELD(nominalRelation);
4107 57319 : READ_UINT_FIELD(rootRelation);
4108 57319 : READ_NODE_FIELD(resultRelations);
4109 57319 : READ_NODE_FIELD(updateColnosLists);
4110 57319 : READ_NODE_FIELD(withCheckOptionLists);
4111 57319 : READ_STRING_FIELD(returningOldAlias);
4112 57319 : READ_STRING_FIELD(returningNewAlias);
4113 57319 : READ_NODE_FIELD(returningLists);
4114 57319 : READ_NODE_FIELD(fdwPrivLists);
4115 57319 : READ_BITMAPSET_FIELD(fdwDirectModifyPlans);
4116 57319 : READ_NODE_FIELD(rowMarks);
4117 57319 : READ_INT_FIELD(epqParam);
4118 57319 : READ_ENUM_FIELD(onConflictAction, OnConflictAction);
4119 57319 : READ_NODE_FIELD(arbiterIndexes);
4120 57319 : READ_ENUM_FIELD(onConflictLockStrength, LockClauseStrength);
4121 57319 : READ_NODE_FIELD(onConflictSet);
4122 57319 : READ_NODE_FIELD(onConflictCols);
4123 57319 : READ_NODE_FIELD(onConflictWhere);
4124 57319 : READ_NODE_FIELD(forPortionOf);
4125 57319 : READ_UINT_FIELD(exclRelRTI);
4126 57319 : READ_NODE_FIELD(exclRelTlist);
4127 57319 : READ_NODE_FIELD(mergeActionLists);
4128 57319 : READ_NODE_FIELD(mergeJoinConditions);
4129 :
4130 57319 : READ_DONE();
4131 : }
4132 :
4133 : static Append *
4134 12526 : _readAppend(void)
4135 : {
4136 12526 : READ_LOCALS(Append);
4137 :
4138 12526 : READ_INT_FIELD(plan.disabled_nodes);
4139 12526 : READ_FLOAT_FIELD(plan.startup_cost);
4140 12526 : READ_FLOAT_FIELD(plan.total_cost);
4141 12526 : READ_FLOAT_FIELD(plan.plan_rows);
4142 12526 : READ_INT_FIELD(plan.plan_width);
4143 12526 : READ_BOOL_FIELD(plan.parallel_aware);
4144 12526 : READ_BOOL_FIELD(plan.parallel_safe);
4145 12526 : READ_BOOL_FIELD(plan.async_capable);
4146 12526 : READ_INT_FIELD(plan.plan_node_id);
4147 12526 : READ_NODE_FIELD(plan.targetlist);
4148 12526 : READ_NODE_FIELD(plan.qual);
4149 12526 : READ_NODE_FIELD(plan.lefttree);
4150 12526 : READ_NODE_FIELD(plan.righttree);
4151 12526 : READ_NODE_FIELD(plan.initPlan);
4152 12526 : READ_BITMAPSET_FIELD(plan.extParam);
4153 12526 : READ_BITMAPSET_FIELD(plan.allParam);
4154 12526 : READ_BITMAPSET_FIELD(apprelids);
4155 12526 : READ_NODE_FIELD(child_append_relid_sets);
4156 12526 : READ_NODE_FIELD(appendplans);
4157 12526 : READ_INT_FIELD(nasyncplans);
4158 12526 : READ_INT_FIELD(first_partial_plan);
4159 12526 : READ_INT_FIELD(part_prune_index);
4160 :
4161 12526 : 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 614 : _readRecursiveUnion(void)
4200 : {
4201 614 : READ_LOCALS(RecursiveUnion);
4202 :
4203 614 : READ_INT_FIELD(plan.disabled_nodes);
4204 614 : READ_FLOAT_FIELD(plan.startup_cost);
4205 614 : READ_FLOAT_FIELD(plan.total_cost);
4206 614 : READ_FLOAT_FIELD(plan.plan_rows);
4207 614 : READ_INT_FIELD(plan.plan_width);
4208 614 : READ_BOOL_FIELD(plan.parallel_aware);
4209 614 : READ_BOOL_FIELD(plan.parallel_safe);
4210 614 : READ_BOOL_FIELD(plan.async_capable);
4211 614 : READ_INT_FIELD(plan.plan_node_id);
4212 614 : READ_NODE_FIELD(plan.targetlist);
4213 614 : READ_NODE_FIELD(plan.qual);
4214 614 : READ_NODE_FIELD(plan.lefttree);
4215 614 : READ_NODE_FIELD(plan.righttree);
4216 614 : READ_NODE_FIELD(plan.initPlan);
4217 614 : READ_BITMAPSET_FIELD(plan.extParam);
4218 614 : READ_BITMAPSET_FIELD(plan.allParam);
4219 614 : READ_INT_FIELD(wtParam);
4220 614 : READ_INT_FIELD(numCols);
4221 614 : READ_ATTRNUMBER_ARRAY(dupColIdx, local_node->numCols);
4222 614 : READ_OID_ARRAY(dupOperators, local_node->numCols);
4223 614 : READ_OID_ARRAY(dupCollations, local_node->numCols);
4224 614 : READ_FLOAT_FIELD(numGroups);
4225 :
4226 614 : READ_DONE();
4227 : }
4228 :
4229 : static BitmapAnd *
4230 146 : _readBitmapAnd(void)
4231 : {
4232 146 : READ_LOCALS(BitmapAnd);
4233 :
4234 146 : READ_INT_FIELD(plan.disabled_nodes);
4235 146 : READ_FLOAT_FIELD(plan.startup_cost);
4236 146 : READ_FLOAT_FIELD(plan.total_cost);
4237 146 : READ_FLOAT_FIELD(plan.plan_rows);
4238 146 : READ_INT_FIELD(plan.plan_width);
4239 146 : READ_BOOL_FIELD(plan.parallel_aware);
4240 146 : READ_BOOL_FIELD(plan.parallel_safe);
4241 146 : READ_BOOL_FIELD(plan.async_capable);
4242 146 : READ_INT_FIELD(plan.plan_node_id);
4243 146 : READ_NODE_FIELD(plan.targetlist);
4244 146 : READ_NODE_FIELD(plan.qual);
4245 146 : READ_NODE_FIELD(plan.lefttree);
4246 146 : READ_NODE_FIELD(plan.righttree);
4247 146 : READ_NODE_FIELD(plan.initPlan);
4248 146 : READ_BITMAPSET_FIELD(plan.extParam);
4249 146 : READ_BITMAPSET_FIELD(plan.allParam);
4250 146 : READ_NODE_FIELD(bitmapplans);
4251 :
4252 146 : READ_DONE();
4253 : }
4254 :
4255 : static BitmapOr *
4256 254 : _readBitmapOr(void)
4257 : {
4258 254 : READ_LOCALS(BitmapOr);
4259 :
4260 254 : READ_INT_FIELD(plan.disabled_nodes);
4261 254 : READ_FLOAT_FIELD(plan.startup_cost);
4262 254 : READ_FLOAT_FIELD(plan.total_cost);
4263 254 : READ_FLOAT_FIELD(plan.plan_rows);
4264 254 : READ_INT_FIELD(plan.plan_width);
4265 254 : READ_BOOL_FIELD(plan.parallel_aware);
4266 254 : READ_BOOL_FIELD(plan.parallel_safe);
4267 254 : READ_BOOL_FIELD(plan.async_capable);
4268 254 : READ_INT_FIELD(plan.plan_node_id);
4269 254 : READ_NODE_FIELD(plan.targetlist);
4270 254 : READ_NODE_FIELD(plan.qual);
4271 254 : READ_NODE_FIELD(plan.lefttree);
4272 254 : READ_NODE_FIELD(plan.righttree);
4273 254 : READ_NODE_FIELD(plan.initPlan);
4274 254 : READ_BITMAPSET_FIELD(plan.extParam);
4275 254 : READ_BITMAPSET_FIELD(plan.allParam);
4276 254 : READ_BOOL_FIELD(isshared);
4277 254 : READ_NODE_FIELD(bitmapplans);
4278 :
4279 254 : READ_DONE();
4280 : }
4281 :
4282 : static SeqScan *
4283 160260 : _readSeqScan(void)
4284 : {
4285 160260 : READ_LOCALS(SeqScan);
4286 :
4287 160260 : READ_INT_FIELD(scan.plan.disabled_nodes);
4288 160260 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4289 160260 : READ_FLOAT_FIELD(scan.plan.total_cost);
4290 160260 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4291 160260 : READ_INT_FIELD(scan.plan.plan_width);
4292 160260 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4293 160260 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4294 160260 : READ_BOOL_FIELD(scan.plan.async_capable);
4295 160260 : READ_INT_FIELD(scan.plan.plan_node_id);
4296 160260 : READ_NODE_FIELD(scan.plan.targetlist);
4297 160260 : READ_NODE_FIELD(scan.plan.qual);
4298 160260 : READ_NODE_FIELD(scan.plan.lefttree);
4299 160260 : READ_NODE_FIELD(scan.plan.righttree);
4300 160260 : READ_NODE_FIELD(scan.plan.initPlan);
4301 160260 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4302 160260 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4303 160260 : READ_UINT_FIELD(scan.scanrelid);
4304 :
4305 160260 : 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 88642 : _readIndexScan(void)
4337 : {
4338 88642 : READ_LOCALS(IndexScan);
4339 :
4340 88642 : READ_INT_FIELD(scan.plan.disabled_nodes);
4341 88642 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4342 88642 : READ_FLOAT_FIELD(scan.plan.total_cost);
4343 88642 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4344 88642 : READ_INT_FIELD(scan.plan.plan_width);
4345 88642 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4346 88642 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4347 88642 : READ_BOOL_FIELD(scan.plan.async_capable);
4348 88642 : READ_INT_FIELD(scan.plan.plan_node_id);
4349 88642 : READ_NODE_FIELD(scan.plan.targetlist);
4350 88642 : READ_NODE_FIELD(scan.plan.qual);
4351 88642 : READ_NODE_FIELD(scan.plan.lefttree);
4352 88642 : READ_NODE_FIELD(scan.plan.righttree);
4353 88642 : READ_NODE_FIELD(scan.plan.initPlan);
4354 88642 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4355 88642 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4356 88642 : READ_UINT_FIELD(scan.scanrelid);
4357 88642 : READ_OID_FIELD(indexid);
4358 88642 : READ_NODE_FIELD(indexqual);
4359 88642 : READ_NODE_FIELD(indexqualorig);
4360 88642 : READ_NODE_FIELD(indexorderby);
4361 88642 : READ_NODE_FIELD(indexorderbyorig);
4362 88642 : READ_NODE_FIELD(indexorderbyops);
4363 88642 : READ_ENUM_FIELD(indexorderdir, ScanDirection);
4364 :
4365 88642 : READ_DONE();
4366 : }
4367 :
4368 : static IndexOnlyScan *
4369 12051 : _readIndexOnlyScan(void)
4370 : {
4371 12051 : READ_LOCALS(IndexOnlyScan);
4372 :
4373 12051 : READ_INT_FIELD(scan.plan.disabled_nodes);
4374 12051 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4375 12051 : READ_FLOAT_FIELD(scan.plan.total_cost);
4376 12051 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4377 12051 : READ_INT_FIELD(scan.plan.plan_width);
4378 12051 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4379 12051 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4380 12051 : READ_BOOL_FIELD(scan.plan.async_capable);
4381 12051 : READ_INT_FIELD(scan.plan.plan_node_id);
4382 12051 : READ_NODE_FIELD(scan.plan.targetlist);
4383 12051 : READ_NODE_FIELD(scan.plan.qual);
4384 12051 : READ_NODE_FIELD(scan.plan.lefttree);
4385 12051 : READ_NODE_FIELD(scan.plan.righttree);
4386 12051 : READ_NODE_FIELD(scan.plan.initPlan);
4387 12051 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4388 12051 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4389 12051 : READ_UINT_FIELD(scan.scanrelid);
4390 12051 : READ_OID_FIELD(indexid);
4391 12051 : READ_NODE_FIELD(indexqual);
4392 12051 : READ_NODE_FIELD(recheckqual);
4393 12051 : READ_NODE_FIELD(indexorderby);
4394 12051 : READ_NODE_FIELD(indextlist);
4395 12051 : READ_ENUM_FIELD(indexorderdir, ScanDirection);
4396 :
4397 12051 : READ_DONE();
4398 : }
4399 :
4400 : static BitmapIndexScan *
4401 17106 : _readBitmapIndexScan(void)
4402 : {
4403 17106 : READ_LOCALS(BitmapIndexScan);
4404 :
4405 17106 : READ_INT_FIELD(scan.plan.disabled_nodes);
4406 17106 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4407 17106 : READ_FLOAT_FIELD(scan.plan.total_cost);
4408 17106 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4409 17106 : READ_INT_FIELD(scan.plan.plan_width);
4410 17106 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4411 17106 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4412 17106 : READ_BOOL_FIELD(scan.plan.async_capable);
4413 17106 : READ_INT_FIELD(scan.plan.plan_node_id);
4414 17106 : READ_NODE_FIELD(scan.plan.targetlist);
4415 17106 : READ_NODE_FIELD(scan.plan.qual);
4416 17106 : READ_NODE_FIELD(scan.plan.lefttree);
4417 17106 : READ_NODE_FIELD(scan.plan.righttree);
4418 17106 : READ_NODE_FIELD(scan.plan.initPlan);
4419 17106 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4420 17106 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4421 17106 : READ_UINT_FIELD(scan.scanrelid);
4422 17106 : READ_OID_FIELD(indexid);
4423 17106 : READ_BOOL_FIELD(isshared);
4424 17106 : READ_NODE_FIELD(indexqual);
4425 17106 : READ_NODE_FIELD(indexqualorig);
4426 :
4427 17106 : READ_DONE();
4428 : }
4429 :
4430 : static BitmapHeapScan *
4431 16702 : _readBitmapHeapScan(void)
4432 : {
4433 16702 : READ_LOCALS(BitmapHeapScan);
4434 :
4435 16702 : READ_INT_FIELD(scan.plan.disabled_nodes);
4436 16702 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4437 16702 : READ_FLOAT_FIELD(scan.plan.total_cost);
4438 16702 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4439 16702 : READ_INT_FIELD(scan.plan.plan_width);
4440 16702 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4441 16702 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4442 16702 : READ_BOOL_FIELD(scan.plan.async_capable);
4443 16702 : READ_INT_FIELD(scan.plan.plan_node_id);
4444 16702 : READ_NODE_FIELD(scan.plan.targetlist);
4445 16702 : READ_NODE_FIELD(scan.plan.qual);
4446 16702 : READ_NODE_FIELD(scan.plan.lefttree);
4447 16702 : READ_NODE_FIELD(scan.plan.righttree);
4448 16702 : READ_NODE_FIELD(scan.plan.initPlan);
4449 16702 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4450 16702 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4451 16702 : READ_UINT_FIELD(scan.scanrelid);
4452 16702 : READ_NODE_FIELD(bitmapqualorig);
4453 :
4454 16702 : 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 14448 : _readSubqueryScan(void)
4513 : {
4514 14448 : READ_LOCALS(SubqueryScan);
4515 :
4516 14448 : READ_INT_FIELD(scan.plan.disabled_nodes);
4517 14448 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4518 14448 : READ_FLOAT_FIELD(scan.plan.total_cost);
4519 14448 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4520 14448 : READ_INT_FIELD(scan.plan.plan_width);
4521 14448 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4522 14448 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4523 14448 : READ_BOOL_FIELD(scan.plan.async_capable);
4524 14448 : READ_INT_FIELD(scan.plan.plan_node_id);
4525 14448 : READ_NODE_FIELD(scan.plan.targetlist);
4526 14448 : READ_NODE_FIELD(scan.plan.qual);
4527 14448 : READ_NODE_FIELD(scan.plan.lefttree);
4528 14448 : READ_NODE_FIELD(scan.plan.righttree);
4529 14448 : READ_NODE_FIELD(scan.plan.initPlan);
4530 14448 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4531 14448 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4532 14448 : READ_UINT_FIELD(scan.scanrelid);
4533 14448 : READ_NODE_FIELD(subplan);
4534 14448 : READ_ENUM_FIELD(scanstatus, SubqueryScanStatus);
4535 :
4536 14448 : READ_DONE();
4537 : }
4538 :
4539 : static FunctionScan *
4540 31639 : _readFunctionScan(void)
4541 : {
4542 31639 : READ_LOCALS(FunctionScan);
4543 :
4544 31639 : READ_INT_FIELD(scan.plan.disabled_nodes);
4545 31639 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4546 31639 : READ_FLOAT_FIELD(scan.plan.total_cost);
4547 31639 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4548 31639 : READ_INT_FIELD(scan.plan.plan_width);
4549 31639 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4550 31639 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4551 31639 : READ_BOOL_FIELD(scan.plan.async_capable);
4552 31639 : READ_INT_FIELD(scan.plan.plan_node_id);
4553 31639 : READ_NODE_FIELD(scan.plan.targetlist);
4554 31639 : READ_NODE_FIELD(scan.plan.qual);
4555 31639 : READ_NODE_FIELD(scan.plan.lefttree);
4556 31639 : READ_NODE_FIELD(scan.plan.righttree);
4557 31639 : READ_NODE_FIELD(scan.plan.initPlan);
4558 31639 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4559 31639 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4560 31639 : READ_UINT_FIELD(scan.scanrelid);
4561 31639 : READ_NODE_FIELD(functions);
4562 31639 : READ_BOOL_FIELD(funcordinality);
4563 :
4564 31639 : READ_DONE();
4565 : }
4566 :
4567 : static ValuesScan *
4568 5689 : _readValuesScan(void)
4569 : {
4570 5689 : READ_LOCALS(ValuesScan);
4571 :
4572 5689 : READ_INT_FIELD(scan.plan.disabled_nodes);
4573 5689 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4574 5689 : READ_FLOAT_FIELD(scan.plan.total_cost);
4575 5689 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4576 5689 : READ_INT_FIELD(scan.plan.plan_width);
4577 5689 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4578 5689 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4579 5689 : READ_BOOL_FIELD(scan.plan.async_capable);
4580 5689 : READ_INT_FIELD(scan.plan.plan_node_id);
4581 5689 : READ_NODE_FIELD(scan.plan.targetlist);
4582 5689 : READ_NODE_FIELD(scan.plan.qual);
4583 5689 : READ_NODE_FIELD(scan.plan.lefttree);
4584 5689 : READ_NODE_FIELD(scan.plan.righttree);
4585 5689 : READ_NODE_FIELD(scan.plan.initPlan);
4586 5689 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4587 5689 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4588 5689 : READ_UINT_FIELD(scan.scanrelid);
4589 5689 : READ_NODE_FIELD(values_lists);
4590 :
4591 5689 : 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 2678 : _readCteScan(void)
4623 : {
4624 2678 : READ_LOCALS(CteScan);
4625 :
4626 2678 : READ_INT_FIELD(scan.plan.disabled_nodes);
4627 2678 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4628 2678 : READ_FLOAT_FIELD(scan.plan.total_cost);
4629 2678 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4630 2678 : READ_INT_FIELD(scan.plan.plan_width);
4631 2678 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4632 2678 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4633 2678 : READ_BOOL_FIELD(scan.plan.async_capable);
4634 2678 : READ_INT_FIELD(scan.plan.plan_node_id);
4635 2678 : READ_NODE_FIELD(scan.plan.targetlist);
4636 2678 : READ_NODE_FIELD(scan.plan.qual);
4637 2678 : READ_NODE_FIELD(scan.plan.lefttree);
4638 2678 : READ_NODE_FIELD(scan.plan.righttree);
4639 2678 : READ_NODE_FIELD(scan.plan.initPlan);
4640 2678 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4641 2678 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4642 2678 : READ_UINT_FIELD(scan.scanrelid);
4643 2678 : READ_INT_FIELD(ctePlanId);
4644 2678 : READ_INT_FIELD(cteParam);
4645 :
4646 2678 : READ_DONE();
4647 : }
4648 :
4649 : static NamedTuplestoreScan *
4650 346 : _readNamedTuplestoreScan(void)
4651 : {
4652 346 : READ_LOCALS(NamedTuplestoreScan);
4653 :
4654 346 : READ_INT_FIELD(scan.plan.disabled_nodes);
4655 346 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4656 346 : READ_FLOAT_FIELD(scan.plan.total_cost);
4657 346 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4658 346 : READ_INT_FIELD(scan.plan.plan_width);
4659 346 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4660 346 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4661 346 : READ_BOOL_FIELD(scan.plan.async_capable);
4662 346 : READ_INT_FIELD(scan.plan.plan_node_id);
4663 346 : READ_NODE_FIELD(scan.plan.targetlist);
4664 346 : READ_NODE_FIELD(scan.plan.qual);
4665 346 : READ_NODE_FIELD(scan.plan.lefttree);
4666 346 : READ_NODE_FIELD(scan.plan.righttree);
4667 346 : READ_NODE_FIELD(scan.plan.initPlan);
4668 346 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4669 346 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4670 346 : READ_UINT_FIELD(scan.scanrelid);
4671 346 : READ_STRING_FIELD(enrname);
4672 :
4673 346 : READ_DONE();
4674 : }
4675 :
4676 : static WorkTableScan *
4677 614 : _readWorkTableScan(void)
4678 : {
4679 614 : READ_LOCALS(WorkTableScan);
4680 :
4681 614 : READ_INT_FIELD(scan.plan.disabled_nodes);
4682 614 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4683 614 : READ_FLOAT_FIELD(scan.plan.total_cost);
4684 614 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4685 614 : READ_INT_FIELD(scan.plan.plan_width);
4686 614 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4687 614 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4688 614 : READ_BOOL_FIELD(scan.plan.async_capable);
4689 614 : READ_INT_FIELD(scan.plan.plan_node_id);
4690 614 : READ_NODE_FIELD(scan.plan.targetlist);
4691 614 : READ_NODE_FIELD(scan.plan.qual);
4692 614 : READ_NODE_FIELD(scan.plan.lefttree);
4693 614 : READ_NODE_FIELD(scan.plan.righttree);
4694 614 : READ_NODE_FIELD(scan.plan.initPlan);
4695 614 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4696 614 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4697 614 : READ_UINT_FIELD(scan.scanrelid);
4698 614 : READ_INT_FIELD(wtParam);
4699 :
4700 614 : READ_DONE();
4701 : }
4702 :
4703 : static ForeignScan *
4704 1043 : _readForeignScan(void)
4705 : {
4706 1043 : READ_LOCALS(ForeignScan);
4707 :
4708 1043 : READ_INT_FIELD(scan.plan.disabled_nodes);
4709 1043 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4710 1043 : READ_FLOAT_FIELD(scan.plan.total_cost);
4711 1043 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4712 1043 : READ_INT_FIELD(scan.plan.plan_width);
4713 1043 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4714 1043 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4715 1043 : READ_BOOL_FIELD(scan.plan.async_capable);
4716 1043 : READ_INT_FIELD(scan.plan.plan_node_id);
4717 1043 : READ_NODE_FIELD(scan.plan.targetlist);
4718 1043 : READ_NODE_FIELD(scan.plan.qual);
4719 1043 : READ_NODE_FIELD(scan.plan.lefttree);
4720 1043 : READ_NODE_FIELD(scan.plan.righttree);
4721 1043 : READ_NODE_FIELD(scan.plan.initPlan);
4722 1043 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4723 1043 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4724 1043 : READ_UINT_FIELD(scan.scanrelid);
4725 1043 : READ_ENUM_FIELD(operation, CmdType);
4726 1043 : READ_UINT_FIELD(resultRelation);
4727 1043 : READ_OID_FIELD(checkAsUser);
4728 1043 : READ_OID_FIELD(fs_server);
4729 1043 : READ_NODE_FIELD(fdw_exprs);
4730 1043 : READ_NODE_FIELD(fdw_private);
4731 1043 : READ_NODE_FIELD(fdw_scan_tlist);
4732 1043 : READ_NODE_FIELD(fdw_recheck_quals);
4733 1043 : READ_BITMAPSET_FIELD(fs_relids);
4734 1043 : READ_BITMAPSET_FIELD(fs_base_relids);
4735 1043 : READ_BOOL_FIELD(fsSystemCol);
4736 :
4737 1043 : 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 66412 : _readNestLoop(void)
4785 : {
4786 66412 : READ_LOCALS(NestLoop);
4787 :
4788 66412 : READ_INT_FIELD(join.plan.disabled_nodes);
4789 66412 : READ_FLOAT_FIELD(join.plan.startup_cost);
4790 66412 : READ_FLOAT_FIELD(join.plan.total_cost);
4791 66412 : READ_FLOAT_FIELD(join.plan.plan_rows);
4792 66412 : READ_INT_FIELD(join.plan.plan_width);
4793 66412 : READ_BOOL_FIELD(join.plan.parallel_aware);
4794 66412 : READ_BOOL_FIELD(join.plan.parallel_safe);
4795 66412 : READ_BOOL_FIELD(join.plan.async_capable);
4796 66412 : READ_INT_FIELD(join.plan.plan_node_id);
4797 66412 : READ_NODE_FIELD(join.plan.targetlist);
4798 66412 : READ_NODE_FIELD(join.plan.qual);
4799 66412 : READ_NODE_FIELD(join.plan.lefttree);
4800 66412 : READ_NODE_FIELD(join.plan.righttree);
4801 66412 : READ_NODE_FIELD(join.plan.initPlan);
4802 66412 : READ_BITMAPSET_FIELD(join.plan.extParam);
4803 66412 : READ_BITMAPSET_FIELD(join.plan.allParam);
4804 66412 : READ_ENUM_FIELD(join.jointype, JoinType);
4805 66412 : READ_BOOL_FIELD(join.inner_unique);
4806 66412 : READ_NODE_FIELD(join.joinqual);
4807 66412 : READ_NODE_FIELD(nestParams);
4808 :
4809 66412 : READ_DONE();
4810 : }
4811 :
4812 : static NestLoopParam *
4813 38575 : _readNestLoopParam(void)
4814 : {
4815 38575 : READ_LOCALS(NestLoopParam);
4816 :
4817 38575 : READ_INT_FIELD(paramno);
4818 38575 : READ_NODE_FIELD(paramval);
4819 :
4820 38575 : READ_DONE();
4821 : }
4822 :
4823 : static MergeJoin *
4824 5108 : _readMergeJoin(void)
4825 : {
4826 5108 : READ_LOCALS(MergeJoin);
4827 :
4828 5108 : READ_INT_FIELD(join.plan.disabled_nodes);
4829 5108 : READ_FLOAT_FIELD(join.plan.startup_cost);
4830 5108 : READ_FLOAT_FIELD(join.plan.total_cost);
4831 5108 : READ_FLOAT_FIELD(join.plan.plan_rows);
4832 5108 : READ_INT_FIELD(join.plan.plan_width);
4833 5108 : READ_BOOL_FIELD(join.plan.parallel_aware);
4834 5108 : READ_BOOL_FIELD(join.plan.parallel_safe);
4835 5108 : READ_BOOL_FIELD(join.plan.async_capable);
4836 5108 : READ_INT_FIELD(join.plan.plan_node_id);
4837 5108 : READ_NODE_FIELD(join.plan.targetlist);
4838 5108 : READ_NODE_FIELD(join.plan.qual);
4839 5108 : READ_NODE_FIELD(join.plan.lefttree);
4840 5108 : READ_NODE_FIELD(join.plan.righttree);
4841 5108 : READ_NODE_FIELD(join.plan.initPlan);
4842 5108 : READ_BITMAPSET_FIELD(join.plan.extParam);
4843 5108 : READ_BITMAPSET_FIELD(join.plan.allParam);
4844 5108 : READ_ENUM_FIELD(join.jointype, JoinType);
4845 5108 : READ_BOOL_FIELD(join.inner_unique);
4846 5108 : READ_NODE_FIELD(join.joinqual);
4847 5108 : READ_BOOL_FIELD(skip_mark_restore);
4848 5108 : READ_NODE_FIELD(mergeclauses);
4849 5108 : READ_OID_ARRAY(mergeFamilies, list_length(local_node->mergeclauses));
4850 5108 : READ_OID_ARRAY(mergeCollations, list_length(local_node->mergeclauses));
4851 5108 : READ_BOOL_ARRAY(mergeReversals, list_length(local_node->mergeclauses));
4852 5108 : READ_BOOL_ARRAY(mergeNullsFirst, list_length(local_node->mergeclauses));
4853 :
4854 5108 : READ_DONE();
4855 : }
4856 :
4857 : static HashJoin *
4858 27556 : _readHashJoin(void)
4859 : {
4860 27556 : READ_LOCALS(HashJoin);
4861 :
4862 27556 : READ_INT_FIELD(join.plan.disabled_nodes);
4863 27556 : READ_FLOAT_FIELD(join.plan.startup_cost);
4864 27556 : READ_FLOAT_FIELD(join.plan.total_cost);
4865 27556 : READ_FLOAT_FIELD(join.plan.plan_rows);
4866 27556 : READ_INT_FIELD(join.plan.plan_width);
4867 27556 : READ_BOOL_FIELD(join.plan.parallel_aware);
4868 27556 : READ_BOOL_FIELD(join.plan.parallel_safe);
4869 27556 : READ_BOOL_FIELD(join.plan.async_capable);
4870 27556 : READ_INT_FIELD(join.plan.plan_node_id);
4871 27556 : READ_NODE_FIELD(join.plan.targetlist);
4872 27556 : READ_NODE_FIELD(join.plan.qual);
4873 27556 : READ_NODE_FIELD(join.plan.lefttree);
4874 27556 : READ_NODE_FIELD(join.plan.righttree);
4875 27556 : READ_NODE_FIELD(join.plan.initPlan);
4876 27556 : READ_BITMAPSET_FIELD(join.plan.extParam);
4877 27556 : READ_BITMAPSET_FIELD(join.plan.allParam);
4878 27556 : READ_ENUM_FIELD(join.jointype, JoinType);
4879 27556 : READ_BOOL_FIELD(join.inner_unique);
4880 27556 : READ_NODE_FIELD(join.joinqual);
4881 27556 : READ_NODE_FIELD(hashclauses);
4882 27556 : READ_NODE_FIELD(hashoperators);
4883 27556 : READ_NODE_FIELD(hashcollations);
4884 27556 : READ_NODE_FIELD(hashkeys);
4885 :
4886 27556 : READ_DONE();
4887 : }
4888 :
4889 : static Material *
4890 2793 : _readMaterial(void)
4891 : {
4892 2793 : READ_LOCALS(Material);
4893 :
4894 2793 : READ_INT_FIELD(plan.disabled_nodes);
4895 2793 : READ_FLOAT_FIELD(plan.startup_cost);
4896 2793 : READ_FLOAT_FIELD(plan.total_cost);
4897 2793 : READ_FLOAT_FIELD(plan.plan_rows);
4898 2793 : READ_INT_FIELD(plan.plan_width);
4899 2793 : READ_BOOL_FIELD(plan.parallel_aware);
4900 2793 : READ_BOOL_FIELD(plan.parallel_safe);
4901 2793 : READ_BOOL_FIELD(plan.async_capable);
4902 2793 : READ_INT_FIELD(plan.plan_node_id);
4903 2793 : READ_NODE_FIELD(plan.targetlist);
4904 2793 : READ_NODE_FIELD(plan.qual);
4905 2793 : READ_NODE_FIELD(plan.lefttree);
4906 2793 : READ_NODE_FIELD(plan.righttree);
4907 2793 : READ_NODE_FIELD(plan.initPlan);
4908 2793 : READ_BITMAPSET_FIELD(plan.extParam);
4909 2793 : READ_BITMAPSET_FIELD(plan.allParam);
4910 :
4911 2793 : READ_DONE();
4912 : }
4913 :
4914 : static Memoize *
4915 1306 : _readMemoize(void)
4916 : {
4917 1306 : READ_LOCALS(Memoize);
4918 :
4919 1306 : READ_INT_FIELD(plan.disabled_nodes);
4920 1306 : READ_FLOAT_FIELD(plan.startup_cost);
4921 1306 : READ_FLOAT_FIELD(plan.total_cost);
4922 1306 : READ_FLOAT_FIELD(plan.plan_rows);
4923 1306 : READ_INT_FIELD(plan.plan_width);
4924 1306 : READ_BOOL_FIELD(plan.parallel_aware);
4925 1306 : READ_BOOL_FIELD(plan.parallel_safe);
4926 1306 : READ_BOOL_FIELD(plan.async_capable);
4927 1306 : READ_INT_FIELD(plan.plan_node_id);
4928 1306 : READ_NODE_FIELD(plan.targetlist);
4929 1306 : READ_NODE_FIELD(plan.qual);
4930 1306 : READ_NODE_FIELD(plan.lefttree);
4931 1306 : READ_NODE_FIELD(plan.righttree);
4932 1306 : READ_NODE_FIELD(plan.initPlan);
4933 1306 : READ_BITMAPSET_FIELD(plan.extParam);
4934 1306 : READ_BITMAPSET_FIELD(plan.allParam);
4935 1306 : READ_INT_FIELD(numKeys);
4936 1306 : READ_OID_ARRAY(hashOperators, local_node->numKeys);
4937 1306 : READ_OID_ARRAY(collations, local_node->numKeys);
4938 1306 : READ_NODE_FIELD(param_exprs);
4939 1306 : READ_BOOL_FIELD(singlerow);
4940 1306 : READ_BOOL_FIELD(binary_mode);
4941 1306 : READ_UINT_FIELD(est_entries);
4942 1306 : READ_BITMAPSET_FIELD(keyparamids);
4943 1306 : READ_FLOAT_FIELD(est_calls);
4944 1306 : READ_FLOAT_FIELD(est_unique_keys);
4945 1306 : READ_FLOAT_FIELD(est_hit_ratio);
4946 :
4947 1306 : READ_DONE();
4948 : }
4949 :
4950 : static Sort *
4951 56345 : _readSort(void)
4952 : {
4953 56345 : READ_LOCALS(Sort);
4954 :
4955 56345 : READ_INT_FIELD(plan.disabled_nodes);
4956 56345 : READ_FLOAT_FIELD(plan.startup_cost);
4957 56345 : READ_FLOAT_FIELD(plan.total_cost);
4958 56345 : READ_FLOAT_FIELD(plan.plan_rows);
4959 56345 : READ_INT_FIELD(plan.plan_width);
4960 56345 : READ_BOOL_FIELD(plan.parallel_aware);
4961 56345 : READ_BOOL_FIELD(plan.parallel_safe);
4962 56345 : READ_BOOL_FIELD(plan.async_capable);
4963 56345 : READ_INT_FIELD(plan.plan_node_id);
4964 56345 : READ_NODE_FIELD(plan.targetlist);
4965 56345 : READ_NODE_FIELD(plan.qual);
4966 56345 : READ_NODE_FIELD(plan.lefttree);
4967 56345 : READ_NODE_FIELD(plan.righttree);
4968 56345 : READ_NODE_FIELD(plan.initPlan);
4969 56345 : READ_BITMAPSET_FIELD(plan.extParam);
4970 56345 : READ_BITMAPSET_FIELD(plan.allParam);
4971 56345 : READ_INT_FIELD(numCols);
4972 56345 : READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
4973 56345 : READ_OID_ARRAY(sortOperators, local_node->numCols);
4974 56345 : READ_OID_ARRAY(collations, local_node->numCols);
4975 56345 : READ_BOOL_ARRAY(nullsFirst, local_node->numCols);
4976 :
4977 56345 : READ_DONE();
4978 : }
4979 :
4980 : static IncrementalSort *
4981 623 : _readIncrementalSort(void)
4982 : {
4983 623 : READ_LOCALS(IncrementalSort);
4984 :
4985 623 : READ_INT_FIELD(sort.plan.disabled_nodes);
4986 623 : READ_FLOAT_FIELD(sort.plan.startup_cost);
4987 623 : READ_FLOAT_FIELD(sort.plan.total_cost);
4988 623 : READ_FLOAT_FIELD(sort.plan.plan_rows);
4989 623 : READ_INT_FIELD(sort.plan.plan_width);
4990 623 : READ_BOOL_FIELD(sort.plan.parallel_aware);
4991 623 : READ_BOOL_FIELD(sort.plan.parallel_safe);
4992 623 : READ_BOOL_FIELD(sort.plan.async_capable);
4993 623 : READ_INT_FIELD(sort.plan.plan_node_id);
4994 623 : READ_NODE_FIELD(sort.plan.targetlist);
4995 623 : READ_NODE_FIELD(sort.plan.qual);
4996 623 : READ_NODE_FIELD(sort.plan.lefttree);
4997 623 : READ_NODE_FIELD(sort.plan.righttree);
4998 623 : READ_NODE_FIELD(sort.plan.initPlan);
4999 623 : READ_BITMAPSET_FIELD(sort.plan.extParam);
5000 623 : READ_BITMAPSET_FIELD(sort.plan.allParam);
5001 623 : READ_INT_FIELD(sort.numCols);
5002 623 : READ_ATTRNUMBER_ARRAY(sort.sortColIdx, local_node->sort.numCols);
5003 623 : READ_OID_ARRAY(sort.sortOperators, local_node->sort.numCols);
5004 623 : READ_OID_ARRAY(sort.collations, local_node->sort.numCols);
5005 623 : READ_BOOL_ARRAY(sort.nullsFirst, local_node->sort.numCols);
5006 623 : READ_INT_FIELD(nPresortedCols);
5007 :
5008 623 : READ_DONE();
5009 : }
5010 :
5011 : static Group *
5012 166 : _readGroup(void)
5013 : {
5014 166 : READ_LOCALS(Group);
5015 :
5016 166 : READ_INT_FIELD(plan.disabled_nodes);
5017 166 : READ_FLOAT_FIELD(plan.startup_cost);
5018 166 : READ_FLOAT_FIELD(plan.total_cost);
5019 166 : READ_FLOAT_FIELD(plan.plan_rows);
5020 166 : READ_INT_FIELD(plan.plan_width);
5021 166 : READ_BOOL_FIELD(plan.parallel_aware);
5022 166 : READ_BOOL_FIELD(plan.parallel_safe);
5023 166 : READ_BOOL_FIELD(plan.async_capable);
5024 166 : READ_INT_FIELD(plan.plan_node_id);
5025 166 : READ_NODE_FIELD(plan.targetlist);
5026 166 : READ_NODE_FIELD(plan.qual);
5027 166 : READ_NODE_FIELD(plan.lefttree);
5028 166 : READ_NODE_FIELD(plan.righttree);
5029 166 : READ_NODE_FIELD(plan.initPlan);
5030 166 : READ_BITMAPSET_FIELD(plan.extParam);
5031 166 : READ_BITMAPSET_FIELD(plan.allParam);
5032 166 : READ_INT_FIELD(numCols);
5033 166 : READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols);
5034 166 : READ_OID_ARRAY(grpOperators, local_node->numCols);
5035 166 : READ_OID_ARRAY(grpCollations, local_node->numCols);
5036 :
5037 166 : READ_DONE();
5038 : }
5039 :
5040 : static Agg *
5041 33240 : _readAgg(void)
5042 : {
5043 33240 : READ_LOCALS(Agg);
5044 :
5045 33240 : READ_INT_FIELD(plan.disabled_nodes);
5046 33240 : READ_FLOAT_FIELD(plan.startup_cost);
5047 33240 : READ_FLOAT_FIELD(plan.total_cost);
5048 33240 : READ_FLOAT_FIELD(plan.plan_rows);
5049 33240 : READ_INT_FIELD(plan.plan_width);
5050 33240 : READ_BOOL_FIELD(plan.parallel_aware);
5051 33240 : READ_BOOL_FIELD(plan.parallel_safe);
5052 33240 : READ_BOOL_FIELD(plan.async_capable);
5053 33240 : READ_INT_FIELD(plan.plan_node_id);
5054 33240 : READ_NODE_FIELD(plan.targetlist);
5055 33240 : READ_NODE_FIELD(plan.qual);
5056 33240 : READ_NODE_FIELD(plan.lefttree);
5057 33240 : READ_NODE_FIELD(plan.righttree);
5058 33240 : READ_NODE_FIELD(plan.initPlan);
5059 33240 : READ_BITMAPSET_FIELD(plan.extParam);
5060 33240 : READ_BITMAPSET_FIELD(plan.allParam);
5061 33240 : READ_ENUM_FIELD(aggstrategy, AggStrategy);
5062 33240 : READ_ENUM_FIELD(aggsplit, AggSplit);
5063 33240 : READ_INT_FIELD(numCols);
5064 33240 : READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols);
5065 33240 : READ_OID_ARRAY(grpOperators, local_node->numCols);
5066 33240 : READ_OID_ARRAY(grpCollations, local_node->numCols);
5067 33240 : READ_FLOAT_FIELD(numGroups);
5068 33240 : READ_UINT64_FIELD(transitionSpace);
5069 33240 : READ_BITMAPSET_FIELD(aggParams);
5070 33240 : READ_NODE_FIELD(groupingSets);
5071 33240 : READ_NODE_FIELD(chain);
5072 :
5073 33240 : READ_DONE();
5074 : }
5075 :
5076 : static WindowAgg *
5077 1910 : _readWindowAgg(void)
5078 : {
5079 1910 : READ_LOCALS(WindowAgg);
5080 :
5081 1910 : READ_INT_FIELD(plan.disabled_nodes);
5082 1910 : READ_FLOAT_FIELD(plan.startup_cost);
5083 1910 : READ_FLOAT_FIELD(plan.total_cost);
5084 1910 : READ_FLOAT_FIELD(plan.plan_rows);
5085 1910 : READ_INT_FIELD(plan.plan_width);
5086 1910 : READ_BOOL_FIELD(plan.parallel_aware);
5087 1910 : READ_BOOL_FIELD(plan.parallel_safe);
5088 1910 : READ_BOOL_FIELD(plan.async_capable);
5089 1910 : READ_INT_FIELD(plan.plan_node_id);
5090 1910 : READ_NODE_FIELD(plan.targetlist);
5091 1910 : READ_NODE_FIELD(plan.qual);
5092 1910 : READ_NODE_FIELD(plan.lefttree);
5093 1910 : READ_NODE_FIELD(plan.righttree);
5094 1910 : READ_NODE_FIELD(plan.initPlan);
5095 1910 : READ_BITMAPSET_FIELD(plan.extParam);
5096 1910 : READ_BITMAPSET_FIELD(plan.allParam);
5097 1910 : READ_STRING_FIELD(winname);
5098 1910 : READ_UINT_FIELD(winref);
5099 1910 : READ_INT_FIELD(partNumCols);
5100 1910 : READ_ATTRNUMBER_ARRAY(partColIdx, local_node->partNumCols);
5101 1910 : READ_OID_ARRAY(partOperators, local_node->partNumCols);
5102 1910 : READ_OID_ARRAY(partCollations, local_node->partNumCols);
5103 1910 : READ_INT_FIELD(ordNumCols);
5104 1910 : READ_ATTRNUMBER_ARRAY(ordColIdx, local_node->ordNumCols);
5105 1910 : READ_OID_ARRAY(ordOperators, local_node->ordNumCols);
5106 1910 : READ_OID_ARRAY(ordCollations, local_node->ordNumCols);
5107 1910 : READ_INT_FIELD(frameOptions);
5108 1910 : READ_NODE_FIELD(startOffset);
5109 1910 : READ_NODE_FIELD(endOffset);
5110 1910 : READ_NODE_FIELD(runCondition);
5111 1910 : READ_NODE_FIELD(runConditionOrig);
5112 1910 : READ_OID_FIELD(startInRangeFunc);
5113 1910 : READ_OID_FIELD(endInRangeFunc);
5114 1910 : READ_OID_FIELD(inRangeColl);
5115 1910 : READ_BOOL_FIELD(inRangeAsc);
5116 1910 : READ_BOOL_FIELD(inRangeNullsFirst);
5117 1910 : READ_BOOL_FIELD(topWindow);
5118 :
5119 1910 : READ_DONE();
5120 : }
5121 :
5122 : static Unique *
5123 3560 : _readUnique(void)
5124 : {
5125 3560 : READ_LOCALS(Unique);
5126 :
5127 3560 : READ_INT_FIELD(plan.disabled_nodes);
5128 3560 : READ_FLOAT_FIELD(plan.startup_cost);
5129 3560 : READ_FLOAT_FIELD(plan.total_cost);
5130 3560 : READ_FLOAT_FIELD(plan.plan_rows);
5131 3560 : READ_INT_FIELD(plan.plan_width);
5132 3560 : READ_BOOL_FIELD(plan.parallel_aware);
5133 3560 : READ_BOOL_FIELD(plan.parallel_safe);
5134 3560 : READ_BOOL_FIELD(plan.async_capable);
5135 3560 : READ_INT_FIELD(plan.plan_node_id);
5136 3560 : READ_NODE_FIELD(plan.targetlist);
5137 3560 : READ_NODE_FIELD(plan.qual);
5138 3560 : READ_NODE_FIELD(plan.lefttree);
5139 3560 : READ_NODE_FIELD(plan.righttree);
5140 3560 : READ_NODE_FIELD(plan.initPlan);
5141 3560 : READ_BITMAPSET_FIELD(plan.extParam);
5142 3560 : READ_BITMAPSET_FIELD(plan.allParam);
5143 3560 : READ_INT_FIELD(numCols);
5144 3560 : READ_ATTRNUMBER_ARRAY(uniqColIdx, local_node->numCols);
5145 3560 : READ_OID_ARRAY(uniqOperators, local_node->numCols);
5146 3560 : READ_OID_ARRAY(uniqCollations, local_node->numCols);
5147 :
5148 3560 : READ_DONE();
5149 : }
5150 :
5151 : static Gather *
5152 768 : _readGather(void)
5153 : {
5154 768 : READ_LOCALS(Gather);
5155 :
5156 768 : READ_INT_FIELD(plan.disabled_nodes);
5157 768 : READ_FLOAT_FIELD(plan.startup_cost);
5158 768 : READ_FLOAT_FIELD(plan.total_cost);
5159 768 : READ_FLOAT_FIELD(plan.plan_rows);
5160 768 : READ_INT_FIELD(plan.plan_width);
5161 768 : READ_BOOL_FIELD(plan.parallel_aware);
5162 768 : READ_BOOL_FIELD(plan.parallel_safe);
5163 768 : READ_BOOL_FIELD(plan.async_capable);
5164 768 : READ_INT_FIELD(plan.plan_node_id);
5165 768 : READ_NODE_FIELD(plan.targetlist);
5166 768 : READ_NODE_FIELD(plan.qual);
5167 768 : READ_NODE_FIELD(plan.lefttree);
5168 768 : READ_NODE_FIELD(plan.righttree);
5169 768 : READ_NODE_FIELD(plan.initPlan);
5170 768 : READ_BITMAPSET_FIELD(plan.extParam);
5171 768 : READ_BITMAPSET_FIELD(plan.allParam);
5172 768 : READ_INT_FIELD(num_workers);
5173 768 : READ_INT_FIELD(rescan_param);
5174 768 : READ_BOOL_FIELD(single_copy);
5175 768 : READ_BOOL_FIELD(invisible);
5176 768 : READ_BITMAPSET_FIELD(initParam);
5177 :
5178 768 : 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 27556 : _readHash(void)
5216 : {
5217 27556 : READ_LOCALS(Hash);
5218 :
5219 27556 : READ_INT_FIELD(plan.disabled_nodes);
5220 27556 : READ_FLOAT_FIELD(plan.startup_cost);
5221 27556 : READ_FLOAT_FIELD(plan.total_cost);
5222 27556 : READ_FLOAT_FIELD(plan.plan_rows);
5223 27556 : READ_INT_FIELD(plan.plan_width);
5224 27556 : READ_BOOL_FIELD(plan.parallel_aware);
5225 27556 : READ_BOOL_FIELD(plan.parallel_safe);
5226 27556 : READ_BOOL_FIELD(plan.async_capable);
5227 27556 : READ_INT_FIELD(plan.plan_node_id);
5228 27556 : READ_NODE_FIELD(plan.targetlist);
5229 27556 : READ_NODE_FIELD(plan.qual);
5230 27556 : READ_NODE_FIELD(plan.lefttree);
5231 27556 : READ_NODE_FIELD(plan.righttree);
5232 27556 : READ_NODE_FIELD(plan.initPlan);
5233 27556 : READ_BITMAPSET_FIELD(plan.extParam);
5234 27556 : READ_BITMAPSET_FIELD(plan.allParam);
5235 27556 : READ_NODE_FIELD(hashkeys);
5236 27556 : READ_OID_FIELD(skewTable);
5237 27556 : READ_INT_FIELD(skewColumn);
5238 27556 : READ_BOOL_FIELD(skewInherit);
5239 27556 : READ_FLOAT_FIELD(rows_total);
5240 :
5241 27556 : 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 6053 : _readLockRows(void)
5279 : {
5280 6053 : READ_LOCALS(LockRows);
5281 :
5282 6053 : READ_INT_FIELD(plan.disabled_nodes);
5283 6053 : READ_FLOAT_FIELD(plan.startup_cost);
5284 6053 : READ_FLOAT_FIELD(plan.total_cost);
5285 6053 : READ_FLOAT_FIELD(plan.plan_rows);
5286 6053 : READ_INT_FIELD(plan.plan_width);
5287 6053 : READ_BOOL_FIELD(plan.parallel_aware);
5288 6053 : READ_BOOL_FIELD(plan.parallel_safe);
5289 6053 : READ_BOOL_FIELD(plan.async_capable);
5290 6053 : READ_INT_FIELD(plan.plan_node_id);
5291 6053 : READ_NODE_FIELD(plan.targetlist);
5292 6053 : READ_NODE_FIELD(plan.qual);
5293 6053 : READ_NODE_FIELD(plan.lefttree);
5294 6053 : READ_NODE_FIELD(plan.righttree);
5295 6053 : READ_NODE_FIELD(plan.initPlan);
5296 6053 : READ_BITMAPSET_FIELD(plan.extParam);
5297 6053 : READ_BITMAPSET_FIELD(plan.allParam);
5298 6053 : READ_NODE_FIELD(rowMarks);
5299 6053 : READ_INT_FIELD(epqParam);
5300 :
5301 6053 : READ_DONE();
5302 : }
5303 :
5304 : static Limit *
5305 3113 : _readLimit(void)
5306 : {
5307 3113 : READ_LOCALS(Limit);
5308 :
5309 3113 : READ_INT_FIELD(plan.disabled_nodes);
5310 3113 : READ_FLOAT_FIELD(plan.startup_cost);
5311 3113 : READ_FLOAT_FIELD(plan.total_cost);
5312 3113 : READ_FLOAT_FIELD(plan.plan_rows);
5313 3113 : READ_INT_FIELD(plan.plan_width);
5314 3113 : READ_BOOL_FIELD(plan.parallel_aware);
5315 3113 : READ_BOOL_FIELD(plan.parallel_safe);
5316 3113 : READ_BOOL_FIELD(plan.async_capable);
5317 3113 : READ_INT_FIELD(plan.plan_node_id);
5318 3113 : READ_NODE_FIELD(plan.targetlist);
5319 3113 : READ_NODE_FIELD(plan.qual);
5320 3113 : READ_NODE_FIELD(plan.lefttree);
5321 3113 : READ_NODE_FIELD(plan.righttree);
5322 3113 : READ_NODE_FIELD(plan.initPlan);
5323 3113 : READ_BITMAPSET_FIELD(plan.extParam);
5324 3113 : READ_BITMAPSET_FIELD(plan.allParam);
5325 3113 : READ_NODE_FIELD(limitOffset);
5326 3113 : READ_NODE_FIELD(limitCount);
5327 3113 : READ_ENUM_FIELD(limitOption, LimitOption);
5328 3113 : READ_INT_FIELD(uniqNumCols);
5329 3113 : READ_ATTRNUMBER_ARRAY(uniqColIdx, local_node->uniqNumCols);
5330 3113 : READ_OID_ARRAY(uniqOperators, local_node->uniqNumCols);
5331 3113 : READ_OID_ARRAY(uniqCollations, local_node->uniqNumCols);
5332 :
5333 3113 : READ_DONE();
5334 : }
5335 :
5336 : static PlanRowMark *
5337 19094 : _readPlanRowMark(void)
5338 : {
5339 19094 : READ_LOCALS(PlanRowMark);
5340 :
5341 19094 : READ_UINT_FIELD(rti);
5342 19094 : READ_UINT_FIELD(prti);
5343 19094 : READ_UINT_FIELD(rowmarkId);
5344 19094 : READ_ENUM_FIELD(markType, RowMarkType);
5345 19094 : READ_INT_FIELD(allMarkTypes);
5346 19094 : READ_ENUM_FIELD(strength, LockClauseStrength);
5347 19094 : READ_ENUM_FIELD(waitPolicy, LockWaitPolicy);
5348 19094 : READ_BOOL_FIELD(isParent);
5349 :
5350 19094 : READ_DONE();
5351 : }
5352 :
5353 : static PartitionPruneInfo *
5354 454 : _readPartitionPruneInfo(void)
5355 : {
5356 454 : READ_LOCALS(PartitionPruneInfo);
5357 :
5358 454 : READ_BITMAPSET_FIELD(relids);
5359 454 : READ_NODE_FIELD(prune_infos);
5360 454 : READ_BITMAPSET_FIELD(other_subplans);
5361 :
5362 454 : READ_DONE();
5363 : }
5364 :
5365 : static PartitionedRelPruneInfo *
5366 909 : _readPartitionedRelPruneInfo(void)
5367 : {
5368 909 : READ_LOCALS(PartitionedRelPruneInfo);
5369 :
5370 909 : READ_UINT_FIELD(rtindex);
5371 909 : READ_BITMAPSET_FIELD(present_parts);
5372 909 : READ_INT_FIELD(nparts);
5373 909 : READ_INT_ARRAY(subplan_map, local_node->nparts);
5374 909 : READ_INT_ARRAY(subpart_map, local_node->nparts);
5375 909 : READ_INT_ARRAY(leafpart_rti_map, local_node->nparts);
5376 909 : READ_OID_ARRAY(relid_map, local_node->nparts);
5377 909 : READ_NODE_FIELD(initial_pruning_steps);
5378 909 : READ_NODE_FIELD(exec_pruning_steps);
5379 909 : READ_BITMAPSET_FIELD(execparamids);
5380 :
5381 909 : READ_DONE();
5382 : }
5383 :
5384 : static PartitionPruneStepOp *
5385 761 : _readPartitionPruneStepOp(void)
5386 : {
5387 761 : READ_LOCALS(PartitionPruneStepOp);
5388 :
5389 761 : READ_INT_FIELD(step.step_id);
5390 761 : READ_INT_FIELD(opstrategy);
5391 761 : READ_NODE_FIELD(exprs);
5392 761 : READ_NODE_FIELD(cmpfns);
5393 761 : READ_BITMAPSET_FIELD(nullkeys);
5394 :
5395 761 : READ_DONE();
5396 : }
5397 :
5398 : static PartitionPruneStepCombine *
5399 142 : _readPartitionPruneStepCombine(void)
5400 : {
5401 142 : READ_LOCALS(PartitionPruneStepCombine);
5402 :
5403 142 : READ_INT_FIELD(step.step_id);
5404 142 : READ_ENUM_FIELD(combineOp, PartitionPruneCombineOp);
5405 142 : READ_NODE_FIELD(source_stepids);
5406 :
5407 142 : READ_DONE();
5408 : }
5409 :
5410 : static PlanInvalItem *
5411 36580 : _readPlanInvalItem(void)
5412 : {
5413 36580 : READ_LOCALS(PlanInvalItem);
5414 :
5415 36580 : READ_INT_FIELD(cacheId);
5416 36580 : READ_UINT_FIELD(hashValue);
5417 :
5418 36580 : READ_DONE();
5419 : }
5420 :
5421 : static SubPlanRTInfo *
5422 56128 : _readSubPlanRTInfo(void)
5423 : {
5424 56128 : READ_LOCALS(SubPlanRTInfo);
5425 :
5426 56128 : READ_STRING_FIELD(plan_name);
5427 56128 : READ_UINT_FIELD(rtoffset);
5428 56128 : READ_BOOL_FIELD(dummy);
5429 :
5430 56128 : READ_DONE();
5431 : }
5432 :
5433 : static ElidedNode *
5434 16215 : _readElidedNode(void)
5435 : {
5436 16215 : READ_LOCALS(ElidedNode);
5437 :
5438 16215 : READ_INT_FIELD(plan_node_id);
5439 16215 : READ_ENUM_FIELD(elided_type, NodeTag);
5440 16215 : READ_BITMAPSET_FIELD(relids);
5441 :
5442 16215 : READ_DONE();
5443 : }
|
