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