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