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