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