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 290266 : _readAlias(void)
44 : {
45 290266 : READ_LOCALS(Alias);
46 :
47 290266 : READ_STRING_FIELD(aliasname);
48 290266 : READ_NODE_FIELD(colnames);
49 :
50 290266 : 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 2394862 : _readVar(void)
114 : {
115 2394862 : READ_LOCALS(Var);
116 :
117 2394862 : READ_INT_FIELD(varno);
118 2394862 : READ_INT_FIELD(varattno);
119 2394862 : READ_OID_FIELD(vartype);
120 2394862 : READ_INT_FIELD(vartypmod);
121 2394862 : READ_OID_FIELD(varcollid);
122 2394862 : READ_BITMAPSET_FIELD(varnullingrels);
123 2394862 : READ_UINT_FIELD(varlevelsup);
124 2394862 : READ_ENUM_FIELD(varreturningtype, VarReturningType);
125 2394862 : READ_UINT_FIELD(varnosyn);
126 2394862 : READ_INT_FIELD(varattnosyn);
127 2394862 : READ_LOCATION_FIELD(location);
128 :
129 2394862 : READ_DONE();
130 : }
131 :
132 : static Param *
133 26204 : _readParam(void)
134 : {
135 26204 : READ_LOCALS(Param);
136 :
137 26204 : READ_ENUM_FIELD(paramkind, ParamKind);
138 26204 : READ_INT_FIELD(paramid);
139 26204 : READ_OID_FIELD(paramtype);
140 26204 : READ_INT_FIELD(paramtypmod);
141 26204 : READ_OID_FIELD(paramcollid);
142 26204 : READ_LOCATION_FIELD(location);
143 :
144 26204 : READ_DONE();
145 : }
146 :
147 : static Aggref *
148 6708 : _readAggref(void)
149 : {
150 6708 : READ_LOCALS(Aggref);
151 :
152 6708 : READ_OID_FIELD(aggfnoid);
153 6708 : READ_OID_FIELD(aggtype);
154 6708 : READ_OID_FIELD(aggcollid);
155 6708 : READ_OID_FIELD(inputcollid);
156 6708 : READ_OID_FIELD(aggtranstype);
157 6708 : READ_NODE_FIELD(aggargtypes);
158 6708 : READ_NODE_FIELD(aggdirectargs);
159 6708 : READ_NODE_FIELD(args);
160 6708 : READ_NODE_FIELD(aggorder);
161 6708 : READ_NODE_FIELD(aggdistinct);
162 6708 : READ_NODE_FIELD(aggfilter);
163 6708 : READ_BOOL_FIELD(aggstar);
164 6708 : READ_BOOL_FIELD(aggvariadic);
165 6708 : READ_CHAR_FIELD(aggkind);
166 6708 : READ_BOOL_FIELD(aggpresorted);
167 6708 : READ_UINT_FIELD(agglevelsup);
168 6708 : READ_ENUM_FIELD(aggsplit, AggSplit);
169 6708 : READ_INT_FIELD(aggno);
170 6708 : READ_INT_FIELD(aggtransno);
171 6708 : READ_LOCATION_FIELD(location);
172 :
173 6708 : 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 350 : _readWindowFunc(void)
192 : {
193 350 : READ_LOCALS(WindowFunc);
194 :
195 350 : READ_OID_FIELD(winfnoid);
196 350 : READ_OID_FIELD(wintype);
197 350 : READ_OID_FIELD(wincollid);
198 350 : READ_OID_FIELD(inputcollid);
199 350 : READ_NODE_FIELD(args);
200 350 : READ_NODE_FIELD(aggfilter);
201 350 : READ_NODE_FIELD(runCondition);
202 350 : READ_UINT_FIELD(winref);
203 350 : READ_BOOL_FIELD(winstar);
204 350 : READ_BOOL_FIELD(winagg);
205 350 : READ_INT_FIELD(ignore_nulls);
206 350 : READ_LOCATION_FIELD(location);
207 :
208 350 : 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 5642 : _readSubscriptingRef(void)
238 : {
239 5642 : READ_LOCALS(SubscriptingRef);
240 :
241 5642 : READ_OID_FIELD(refcontainertype);
242 5642 : READ_OID_FIELD(refelemtype);
243 5642 : READ_OID_FIELD(refrestype);
244 5642 : READ_INT_FIELD(reftypmod);
245 5642 : READ_OID_FIELD(refcollid);
246 5642 : READ_NODE_FIELD(refupperindexpr);
247 5642 : READ_NODE_FIELD(reflowerindexpr);
248 5642 : READ_NODE_FIELD(refexpr);
249 5642 : READ_NODE_FIELD(refassgnexpr);
250 :
251 5642 : READ_DONE();
252 : }
253 :
254 : static FuncExpr *
255 306228 : _readFuncExpr(void)
256 : {
257 306228 : READ_LOCALS(FuncExpr);
258 :
259 306228 : READ_OID_FIELD(funcid);
260 306228 : READ_OID_FIELD(funcresulttype);
261 306228 : READ_BOOL_FIELD(funcretset);
262 306228 : READ_BOOL_FIELD(funcvariadic);
263 306228 : READ_ENUM_FIELD(funcformat, CoercionForm);
264 306228 : READ_OID_FIELD(funccollid);
265 306228 : READ_OID_FIELD(inputcollid);
266 306228 : READ_NODE_FIELD(args);
267 306228 : READ_LOCATION_FIELD(location);
268 :
269 306228 : 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 200618 : _readOpExpr(void)
287 : {
288 200618 : READ_LOCALS(OpExpr);
289 :
290 200618 : READ_OID_FIELD(opno);
291 200618 : READ_OID_FIELD(opfuncid);
292 200618 : READ_OID_FIELD(opresulttype);
293 200618 : READ_BOOL_FIELD(opretset);
294 200618 : READ_OID_FIELD(opcollid);
295 200618 : READ_OID_FIELD(inputcollid);
296 200618 : READ_NODE_FIELD(args);
297 200618 : READ_LOCATION_FIELD(location);
298 :
299 200618 : 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 856 : _readNullIfExpr(void)
321 : {
322 856 : READ_LOCALS(NullIfExpr);
323 :
324 856 : READ_OID_FIELD(opno);
325 856 : READ_OID_FIELD(opfuncid);
326 856 : READ_OID_FIELD(opresulttype);
327 856 : READ_BOOL_FIELD(opretset);
328 856 : READ_OID_FIELD(opcollid);
329 856 : READ_OID_FIELD(inputcollid);
330 856 : READ_NODE_FIELD(args);
331 856 : READ_LOCATION_FIELD(location);
332 :
333 856 : READ_DONE();
334 : }
335 :
336 : static ScalarArrayOpExpr *
337 10376 : _readScalarArrayOpExpr(void)
338 : {
339 10376 : READ_LOCALS(ScalarArrayOpExpr);
340 :
341 10376 : READ_OID_FIELD(opno);
342 10376 : READ_OID_FIELD(opfuncid);
343 10376 : READ_OID_FIELD(hashfuncid);
344 10376 : READ_OID_FIELD(negfuncid);
345 10376 : READ_BOOL_FIELD(useOr);
346 10376 : READ_OID_FIELD(inputcollid);
347 10376 : READ_NODE_FIELD(args);
348 10376 : READ_LOCATION_FIELD(location);
349 :
350 10376 : READ_DONE();
351 : }
352 :
353 : static SubLink *
354 6632 : _readSubLink(void)
355 : {
356 6632 : READ_LOCALS(SubLink);
357 :
358 6632 : READ_ENUM_FIELD(subLinkType, SubLinkType);
359 6632 : READ_INT_FIELD(subLinkId);
360 6632 : READ_NODE_FIELD(testexpr);
361 6632 : READ_NODE_FIELD(operName);
362 6632 : READ_NODE_FIELD(subselect);
363 6632 : READ_LOCATION_FIELD(location);
364 :
365 6632 : 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 21016 : _readFieldSelect(void)
406 : {
407 21016 : READ_LOCALS(FieldSelect);
408 :
409 21016 : READ_NODE_FIELD(arg);
410 21016 : READ_INT_FIELD(fieldnum);
411 21016 : READ_OID_FIELD(resulttype);
412 21016 : READ_INT_FIELD(resulttypmod);
413 21016 : READ_OID_FIELD(resultcollid);
414 :
415 21016 : 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 23150 : _readRelabelType(void)
433 : {
434 23150 : READ_LOCALS(RelabelType);
435 :
436 23150 : READ_NODE_FIELD(arg);
437 23150 : READ_OID_FIELD(resulttype);
438 23150 : READ_INT_FIELD(resulttypmod);
439 23150 : READ_OID_FIELD(resultcollid);
440 23150 : READ_ENUM_FIELD(relabelformat, CoercionForm);
441 23150 : READ_LOCATION_FIELD(location);
442 :
443 23150 : READ_DONE();
444 : }
445 :
446 : static CoerceViaIO *
447 7056 : _readCoerceViaIO(void)
448 : {
449 7056 : READ_LOCALS(CoerceViaIO);
450 :
451 7056 : READ_NODE_FIELD(arg);
452 7056 : READ_OID_FIELD(resulttype);
453 7056 : READ_OID_FIELD(resultcollid);
454 7056 : READ_ENUM_FIELD(coerceformat, CoercionForm);
455 7056 : READ_LOCATION_FIELD(location);
456 :
457 7056 : READ_DONE();
458 : }
459 :
460 : static ArrayCoerceExpr *
461 992 : _readArrayCoerceExpr(void)
462 : {
463 992 : READ_LOCALS(ArrayCoerceExpr);
464 :
465 992 : READ_NODE_FIELD(arg);
466 992 : READ_NODE_FIELD(elemexpr);
467 992 : READ_OID_FIELD(resulttype);
468 992 : READ_INT_FIELD(resulttypmod);
469 992 : READ_OID_FIELD(resultcollid);
470 992 : READ_ENUM_FIELD(coerceformat, CoercionForm);
471 992 : READ_LOCATION_FIELD(location);
472 :
473 992 : 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 23838 : _readCaseExpr(void)
503 : {
504 23838 : READ_LOCALS(CaseExpr);
505 :
506 23838 : READ_OID_FIELD(casetype);
507 23838 : READ_OID_FIELD(casecollid);
508 23838 : READ_NODE_FIELD(arg);
509 23838 : READ_NODE_FIELD(args);
510 23838 : READ_NODE_FIELD(defresult);
511 23838 : READ_LOCATION_FIELD(location);
512 :
513 23838 : READ_DONE();
514 : }
515 :
516 : static CaseWhen *
517 53304 : _readCaseWhen(void)
518 : {
519 53304 : READ_LOCALS(CaseWhen);
520 :
521 53304 : READ_NODE_FIELD(expr);
522 53304 : READ_NODE_FIELD(result);
523 53304 : READ_LOCATION_FIELD(location);
524 :
525 53304 : READ_DONE();
526 : }
527 :
528 : static CaseTestExpr *
529 14844 : _readCaseTestExpr(void)
530 : {
531 14844 : READ_LOCALS(CaseTestExpr);
532 :
533 14844 : READ_OID_FIELD(typeId);
534 14844 : READ_INT_FIELD(typeMod);
535 14844 : READ_OID_FIELD(collation);
536 :
537 14844 : READ_DONE();
538 : }
539 :
540 : static ArrayExpr *
541 10112 : _readArrayExpr(void)
542 : {
543 10112 : READ_LOCALS(ArrayExpr);
544 :
545 10112 : READ_OID_FIELD(array_typeid);
546 10112 : READ_OID_FIELD(array_collid);
547 10112 : READ_OID_FIELD(element_typeid);
548 10112 : READ_NODE_FIELD(elements);
549 10112 : READ_BOOL_FIELD(multidims);
550 10112 : READ_LOCATION_FIELD(list_start);
551 10112 : READ_LOCATION_FIELD(list_end);
552 10112 : READ_LOCATION_FIELD(location);
553 :
554 10112 : 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 9216 : _readCoalesceExpr(void)
588 : {
589 9216 : READ_LOCALS(CoalesceExpr);
590 :
591 9216 : READ_OID_FIELD(coalescetype);
592 9216 : READ_OID_FIELD(coalescecollid);
593 9216 : READ_NODE_FIELD(args);
594 9216 : READ_LOCATION_FIELD(location);
595 :
596 9216 : 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 2252 : _readSQLValueFunction(void)
616 : {
617 2252 : READ_LOCALS(SQLValueFunction);
618 :
619 2252 : READ_ENUM_FIELD(op, SQLValueFunctionOp);
620 2252 : READ_OID_FIELD(type);
621 2252 : READ_INT_FIELD(typmod);
622 2252 : READ_LOCATION_FIELD(location);
623 :
624 2252 : 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 3740 : _readNullTest(void)
789 : {
790 3740 : READ_LOCALS(NullTest);
791 :
792 3740 : READ_NODE_FIELD(arg);
793 3740 : READ_ENUM_FIELD(nulltesttype, NullTestType);
794 3740 : READ_BOOL_FIELD(argisrow);
795 3740 : READ_LOCATION_FIELD(location);
796 :
797 3740 : 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 95770 : _readCoerceToDomain(void)
829 : {
830 95770 : READ_LOCALS(CoerceToDomain);
831 :
832 95770 : READ_NODE_FIELD(arg);
833 95770 : READ_OID_FIELD(resulttype);
834 95770 : READ_INT_FIELD(resulttypmod);
835 95770 : READ_OID_FIELD(resultcollid);
836 95770 : READ_ENUM_FIELD(coercionformat, CoercionForm);
837 95770 : READ_LOCATION_FIELD(location);
838 :
839 95770 : READ_DONE();
840 : }
841 :
842 : static CoerceToDomainValue *
843 1980 : _readCoerceToDomainValue(void)
844 : {
845 1980 : READ_LOCALS(CoerceToDomainValue);
846 :
847 1980 : READ_OID_FIELD(typeId);
848 1980 : READ_INT_FIELD(typeMod);
849 1980 : READ_OID_FIELD(collation);
850 1980 : READ_LOCATION_FIELD(location);
851 :
852 1980 : 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 507156 : _readTargetEntry(void)
917 : {
918 507156 : READ_LOCALS(TargetEntry);
919 :
920 507156 : READ_NODE_FIELD(expr);
921 507156 : READ_INT_FIELD(resno);
922 507156 : READ_STRING_FIELD(resname);
923 507156 : READ_UINT_FIELD(ressortgroupref);
924 507156 : READ_OID_FIELD(resorigtbl);
925 507156 : READ_INT_FIELD(resorigcol);
926 507156 : READ_BOOL_FIELD(resjunk);
927 :
928 507156 : READ_DONE();
929 : }
930 :
931 : static RangeTblRef *
932 136802 : _readRangeTblRef(void)
933 : {
934 136802 : READ_LOCALS(RangeTblRef);
935 :
936 136802 : READ_INT_FIELD(rtindex);
937 :
938 136802 : READ_DONE();
939 : }
940 :
941 : static JoinExpr *
942 36012 : _readJoinExpr(void)
943 : {
944 36012 : READ_LOCALS(JoinExpr);
945 :
946 36012 : READ_ENUM_FIELD(jointype, JoinType);
947 36012 : READ_BOOL_FIELD(isNatural);
948 36012 : READ_NODE_FIELD(larg);
949 36012 : READ_NODE_FIELD(rarg);
950 36012 : READ_NODE_FIELD(usingClause);
951 36012 : READ_NODE_FIELD(join_using_alias);
952 36012 : READ_NODE_FIELD(quals);
953 36012 : READ_NODE_FIELD(alias);
954 36012 : READ_INT_FIELD(rtindex);
955 :
956 36012 : READ_DONE();
957 : }
958 :
959 : static FromExpr *
960 81250 : _readFromExpr(void)
961 : {
962 81250 : READ_LOCALS(FromExpr);
963 :
964 81250 : READ_NODE_FIELD(fromlist);
965 81250 : READ_NODE_FIELD(quals);
966 :
967 81250 : 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 81376 : _readQuery(void)
989 : {
990 81376 : READ_LOCALS(Query);
991 :
992 81376 : READ_ENUM_FIELD(commandType, CmdType);
993 81376 : READ_ENUM_FIELD(querySource, QuerySource);
994 81376 : local_node->queryId = 0;
995 81376 : READ_BOOL_FIELD(canSetTag);
996 81376 : READ_NODE_FIELD(utilityStmt);
997 81376 : READ_INT_FIELD(resultRelation);
998 81376 : READ_BOOL_FIELD(hasAggs);
999 81376 : READ_BOOL_FIELD(hasWindowFuncs);
1000 81376 : READ_BOOL_FIELD(hasTargetSRFs);
1001 81376 : READ_BOOL_FIELD(hasSubLinks);
1002 81376 : READ_BOOL_FIELD(hasDistinctOn);
1003 81376 : READ_BOOL_FIELD(hasRecursive);
1004 81376 : READ_BOOL_FIELD(hasModifyingCTE);
1005 81376 : READ_BOOL_FIELD(hasForUpdate);
1006 81376 : READ_BOOL_FIELD(hasRowSecurity);
1007 81376 : READ_BOOL_FIELD(hasGroupRTE);
1008 81376 : READ_BOOL_FIELD(isReturn);
1009 81376 : READ_NODE_FIELD(cteList);
1010 81376 : READ_NODE_FIELD(rtable);
1011 81376 : READ_NODE_FIELD(rteperminfos);
1012 81376 : READ_NODE_FIELD(jointree);
1013 81376 : READ_NODE_FIELD(mergeActionList);
1014 81376 : READ_INT_FIELD(mergeTargetRelation);
1015 81376 : READ_NODE_FIELD(mergeJoinCondition);
1016 81376 : READ_NODE_FIELD(targetList);
1017 81376 : READ_ENUM_FIELD(override, OverridingKind);
1018 81376 : READ_NODE_FIELD(onConflict);
1019 81376 : READ_STRING_FIELD(returningOldAlias);
1020 81376 : READ_STRING_FIELD(returningNewAlias);
1021 81376 : READ_NODE_FIELD(returningList);
1022 81376 : READ_NODE_FIELD(groupClause);
1023 81376 : READ_BOOL_FIELD(groupDistinct);
1024 81376 : READ_BOOL_FIELD(groupByAll);
1025 81376 : READ_NODE_FIELD(groupingSets);
1026 81376 : READ_NODE_FIELD(havingQual);
1027 81376 : READ_NODE_FIELD(windowClause);
1028 81376 : READ_NODE_FIELD(distinctClause);
1029 81376 : READ_NODE_FIELD(sortClause);
1030 81376 : READ_NODE_FIELD(limitOffset);
1031 81376 : READ_NODE_FIELD(limitCount);
1032 81376 : READ_ENUM_FIELD(limitOption, LimitOption);
1033 81376 : READ_NODE_FIELD(rowMarks);
1034 81376 : READ_NODE_FIELD(setOperations);
1035 81376 : READ_NODE_FIELD(constraintDeps);
1036 81376 : READ_NODE_FIELD(withCheckOptions);
1037 81376 : READ_LOCATION_FIELD(stmt_location);
1038 81376 : READ_LOCATION_FIELD(stmt_len);
1039 :
1040 81376 : 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 41354 : _readPartitionBoundSpec(void)
1438 : {
1439 41354 : READ_LOCALS(PartitionBoundSpec);
1440 :
1441 41354 : READ_CHAR_FIELD(strategy);
1442 41354 : READ_BOOL_FIELD(is_default);
1443 41354 : READ_INT_FIELD(modulus);
1444 41354 : READ_INT_FIELD(remainder);
1445 41354 : READ_NODE_FIELD(listdatums);
1446 41354 : READ_NODE_FIELD(lowerdatums);
1447 41354 : READ_NODE_FIELD(upperdatums);
1448 41354 : READ_LOCATION_FIELD(location);
1449 :
1450 41354 : READ_DONE();
1451 : }
1452 :
1453 : static PartitionRangeDatum *
1454 47440 : _readPartitionRangeDatum(void)
1455 : {
1456 47440 : READ_LOCALS(PartitionRangeDatum);
1457 :
1458 47440 : READ_ENUM_FIELD(kind, PartitionRangeDatumKind);
1459 47440 : READ_NODE_FIELD(value);
1460 47440 : READ_LOCATION_FIELD(location);
1461 :
1462 47440 : READ_DONE();
1463 : }
1464 :
1465 : static PartitionCmd *
1466 0 : _readPartitionCmd(void)
1467 : {
1468 0 : READ_LOCALS(PartitionCmd);
1469 :
1470 0 : READ_NODE_FIELD(name);
1471 0 : READ_NODE_FIELD(bound);
1472 0 : READ_BOOL_FIELD(concurrent);
1473 :
1474 0 : READ_DONE();
1475 : }
1476 :
1477 : static RTEPermissionInfo *
1478 112010 : _readRTEPermissionInfo(void)
1479 : {
1480 112010 : READ_LOCALS(RTEPermissionInfo);
1481 :
1482 112010 : READ_OID_FIELD(relid);
1483 112010 : READ_BOOL_FIELD(inh);
1484 112010 : READ_UINT64_FIELD(requiredPerms);
1485 112010 : READ_OID_FIELD(checkAsUser);
1486 112010 : READ_BITMAPSET_FIELD(selectedCols);
1487 112010 : READ_BITMAPSET_FIELD(insertedCols);
1488 112010 : READ_BITMAPSET_FIELD(updatedCols);
1489 :
1490 112010 : READ_DONE();
1491 : }
1492 :
1493 : static RangeTblFunction *
1494 13614 : _readRangeTblFunction(void)
1495 : {
1496 13614 : READ_LOCALS(RangeTblFunction);
1497 :
1498 13614 : READ_NODE_FIELD(funcexpr);
1499 13614 : READ_INT_FIELD(funccolcount);
1500 13614 : READ_NODE_FIELD(funccolnames);
1501 13614 : READ_NODE_FIELD(funccoltypes);
1502 13614 : READ_NODE_FIELD(funccoltypmods);
1503 13614 : READ_NODE_FIELD(funccolcollations);
1504 13614 : READ_BITMAPSET_FIELD(funcparams);
1505 :
1506 13614 : READ_DONE();
1507 : }
1508 :
1509 : static TableSampleClause *
1510 88 : _readTableSampleClause(void)
1511 : {
1512 88 : READ_LOCALS(TableSampleClause);
1513 :
1514 88 : READ_OID_FIELD(tsmhandler);
1515 88 : READ_NODE_FIELD(args);
1516 88 : READ_NODE_FIELD(repeatable);
1517 :
1518 88 : READ_DONE();
1519 : }
1520 :
1521 : static WithCheckOption *
1522 0 : _readWithCheckOption(void)
1523 : {
1524 0 : READ_LOCALS(WithCheckOption);
1525 :
1526 0 : READ_ENUM_FIELD(kind, WCOKind);
1527 0 : READ_STRING_FIELD(relname);
1528 0 : READ_STRING_FIELD(polname);
1529 0 : READ_NODE_FIELD(qual);
1530 0 : READ_BOOL_FIELD(cascaded);
1531 :
1532 0 : READ_DONE();
1533 : }
1534 :
1535 : static SortGroupClause *
1536 17126 : _readSortGroupClause(void)
1537 : {
1538 17126 : READ_LOCALS(SortGroupClause);
1539 :
1540 17126 : READ_UINT_FIELD(tleSortGroupRef);
1541 17126 : READ_OID_FIELD(eqop);
1542 17126 : READ_OID_FIELD(sortop);
1543 17126 : READ_BOOL_FIELD(reverse_sort);
1544 17126 : READ_BOOL_FIELD(nulls_first);
1545 17126 : READ_BOOL_FIELD(hashable);
1546 :
1547 17126 : READ_DONE();
1548 : }
1549 :
1550 : static GroupingSet *
1551 72 : _readGroupingSet(void)
1552 : {
1553 72 : READ_LOCALS(GroupingSet);
1554 :
1555 72 : READ_ENUM_FIELD(kind, GroupingSetKind);
1556 72 : READ_NODE_FIELD(content);
1557 72 : READ_LOCATION_FIELD(location);
1558 :
1559 72 : READ_DONE();
1560 : }
1561 :
1562 : static WindowClause *
1563 314 : _readWindowClause(void)
1564 : {
1565 314 : READ_LOCALS(WindowClause);
1566 :
1567 314 : READ_STRING_FIELD(name);
1568 314 : READ_STRING_FIELD(refname);
1569 314 : READ_NODE_FIELD(partitionClause);
1570 314 : READ_NODE_FIELD(orderClause);
1571 314 : READ_INT_FIELD(frameOptions);
1572 314 : READ_NODE_FIELD(startOffset);
1573 314 : READ_NODE_FIELD(endOffset);
1574 314 : READ_OID_FIELD(startInRangeFunc);
1575 314 : READ_OID_FIELD(endInRangeFunc);
1576 314 : READ_OID_FIELD(inRangeColl);
1577 314 : READ_BOOL_FIELD(inRangeAsc);
1578 314 : READ_BOOL_FIELD(inRangeNullsFirst);
1579 314 : READ_UINT_FIELD(winref);
1580 314 : READ_BOOL_FIELD(copiedOrder);
1581 :
1582 314 : READ_DONE();
1583 : }
1584 :
1585 : static RowMarkClause *
1586 30 : _readRowMarkClause(void)
1587 : {
1588 30 : READ_LOCALS(RowMarkClause);
1589 :
1590 30 : READ_UINT_FIELD(rti);
1591 30 : READ_ENUM_FIELD(strength, LockClauseStrength);
1592 30 : READ_ENUM_FIELD(waitPolicy, LockWaitPolicy);
1593 30 : READ_BOOL_FIELD(pushedDown);
1594 :
1595 30 : READ_DONE();
1596 : }
1597 :
1598 : static WithClause *
1599 0 : _readWithClause(void)
1600 : {
1601 0 : READ_LOCALS(WithClause);
1602 :
1603 0 : READ_NODE_FIELD(ctes);
1604 0 : READ_BOOL_FIELD(recursive);
1605 0 : READ_LOCATION_FIELD(location);
1606 :
1607 0 : READ_DONE();
1608 : }
1609 :
1610 : static InferClause *
1611 0 : _readInferClause(void)
1612 : {
1613 0 : READ_LOCALS(InferClause);
1614 :
1615 0 : READ_NODE_FIELD(indexElems);
1616 0 : READ_NODE_FIELD(whereClause);
1617 0 : READ_STRING_FIELD(conname);
1618 0 : READ_LOCATION_FIELD(location);
1619 :
1620 0 : READ_DONE();
1621 : }
1622 :
1623 : static OnConflictClause *
1624 0 : _readOnConflictClause(void)
1625 : {
1626 0 : READ_LOCALS(OnConflictClause);
1627 :
1628 0 : READ_ENUM_FIELD(action, OnConflictAction);
1629 0 : READ_NODE_FIELD(infer);
1630 0 : READ_NODE_FIELD(targetList);
1631 0 : READ_NODE_FIELD(whereClause);
1632 0 : READ_LOCATION_FIELD(location);
1633 :
1634 0 : READ_DONE();
1635 : }
1636 :
1637 : static CTESearchClause *
1638 18 : _readCTESearchClause(void)
1639 : {
1640 18 : READ_LOCALS(CTESearchClause);
1641 :
1642 18 : READ_NODE_FIELD(search_col_list);
1643 18 : READ_BOOL_FIELD(search_breadth_first);
1644 18 : READ_STRING_FIELD(search_seq_column);
1645 18 : READ_LOCATION_FIELD(location);
1646 :
1647 18 : READ_DONE();
1648 : }
1649 :
1650 : static CTECycleClause *
1651 36 : _readCTECycleClause(void)
1652 : {
1653 36 : READ_LOCALS(CTECycleClause);
1654 :
1655 36 : READ_NODE_FIELD(cycle_col_list);
1656 36 : READ_STRING_FIELD(cycle_mark_column);
1657 36 : READ_NODE_FIELD(cycle_mark_value);
1658 36 : READ_NODE_FIELD(cycle_mark_default);
1659 36 : READ_STRING_FIELD(cycle_path_column);
1660 36 : READ_LOCATION_FIELD(location);
1661 36 : READ_OID_FIELD(cycle_mark_type);
1662 36 : READ_INT_FIELD(cycle_mark_typmod);
1663 36 : READ_OID_FIELD(cycle_mark_collation);
1664 36 : READ_OID_FIELD(cycle_mark_neop);
1665 :
1666 36 : READ_DONE();
1667 : }
1668 :
1669 : static CommonTableExpr *
1670 388 : _readCommonTableExpr(void)
1671 : {
1672 388 : READ_LOCALS(CommonTableExpr);
1673 :
1674 388 : READ_STRING_FIELD(ctename);
1675 388 : READ_NODE_FIELD(aliascolnames);
1676 388 : READ_ENUM_FIELD(ctematerialized, CTEMaterialize);
1677 388 : READ_NODE_FIELD(ctequery);
1678 388 : READ_NODE_FIELD(search_clause);
1679 388 : READ_NODE_FIELD(cycle_clause);
1680 388 : READ_LOCATION_FIELD(location);
1681 388 : READ_BOOL_FIELD(cterecursive);
1682 388 : READ_INT_FIELD(cterefcount);
1683 388 : READ_NODE_FIELD(ctecolnames);
1684 388 : READ_NODE_FIELD(ctecoltypes);
1685 388 : READ_NODE_FIELD(ctecoltypmods);
1686 388 : READ_NODE_FIELD(ctecolcollations);
1687 :
1688 388 : READ_DONE();
1689 : }
1690 :
1691 : static MergeWhenClause *
1692 0 : _readMergeWhenClause(void)
1693 : {
1694 0 : READ_LOCALS(MergeWhenClause);
1695 :
1696 0 : READ_ENUM_FIELD(matchKind, MergeMatchKind);
1697 0 : READ_ENUM_FIELD(commandType, CmdType);
1698 0 : READ_ENUM_FIELD(override, OverridingKind);
1699 0 : READ_NODE_FIELD(condition);
1700 0 : READ_NODE_FIELD(targetList);
1701 0 : READ_NODE_FIELD(values);
1702 :
1703 0 : READ_DONE();
1704 : }
1705 :
1706 : static ReturningOption *
1707 0 : _readReturningOption(void)
1708 : {
1709 0 : READ_LOCALS(ReturningOption);
1710 :
1711 0 : READ_ENUM_FIELD(option, ReturningOptionKind);
1712 0 : READ_STRING_FIELD(value);
1713 0 : READ_LOCATION_FIELD(location);
1714 :
1715 0 : READ_DONE();
1716 : }
1717 :
1718 : static ReturningClause *
1719 0 : _readReturningClause(void)
1720 : {
1721 0 : READ_LOCALS(ReturningClause);
1722 :
1723 0 : READ_NODE_FIELD(options);
1724 0 : READ_NODE_FIELD(exprs);
1725 :
1726 0 : READ_DONE();
1727 : }
1728 :
1729 : static TriggerTransition *
1730 0 : _readTriggerTransition(void)
1731 : {
1732 0 : READ_LOCALS(TriggerTransition);
1733 :
1734 0 : READ_STRING_FIELD(name);
1735 0 : READ_BOOL_FIELD(isNew);
1736 0 : READ_BOOL_FIELD(isTable);
1737 :
1738 0 : READ_DONE();
1739 : }
1740 :
1741 : static JsonOutput *
1742 0 : _readJsonOutput(void)
1743 : {
1744 0 : READ_LOCALS(JsonOutput);
1745 :
1746 0 : READ_NODE_FIELD(typeName);
1747 0 : READ_NODE_FIELD(returning);
1748 :
1749 0 : READ_DONE();
1750 : }
1751 :
1752 : static JsonArgument *
1753 0 : _readJsonArgument(void)
1754 : {
1755 0 : READ_LOCALS(JsonArgument);
1756 :
1757 0 : READ_NODE_FIELD(val);
1758 0 : READ_STRING_FIELD(name);
1759 :
1760 0 : READ_DONE();
1761 : }
1762 :
1763 : static JsonFuncExpr *
1764 0 : _readJsonFuncExpr(void)
1765 : {
1766 0 : READ_LOCALS(JsonFuncExpr);
1767 :
1768 0 : READ_ENUM_FIELD(op, JsonExprOp);
1769 0 : READ_STRING_FIELD(column_name);
1770 0 : READ_NODE_FIELD(context_item);
1771 0 : READ_NODE_FIELD(pathspec);
1772 0 : READ_NODE_FIELD(passing);
1773 0 : READ_NODE_FIELD(output);
1774 0 : READ_NODE_FIELD(on_empty);
1775 0 : READ_NODE_FIELD(on_error);
1776 0 : READ_ENUM_FIELD(wrapper, JsonWrapper);
1777 0 : READ_ENUM_FIELD(quotes, JsonQuotes);
1778 0 : READ_LOCATION_FIELD(location);
1779 :
1780 0 : READ_DONE();
1781 : }
1782 :
1783 : static JsonTablePathSpec *
1784 0 : _readJsonTablePathSpec(void)
1785 : {
1786 0 : READ_LOCALS(JsonTablePathSpec);
1787 :
1788 0 : READ_NODE_FIELD(string);
1789 0 : READ_STRING_FIELD(name);
1790 0 : READ_LOCATION_FIELD(name_location);
1791 0 : READ_LOCATION_FIELD(location);
1792 :
1793 0 : READ_DONE();
1794 : }
1795 :
1796 : static JsonTable *
1797 0 : _readJsonTable(void)
1798 : {
1799 0 : READ_LOCALS(JsonTable);
1800 :
1801 0 : READ_NODE_FIELD(context_item);
1802 0 : READ_NODE_FIELD(pathspec);
1803 0 : READ_NODE_FIELD(passing);
1804 0 : READ_NODE_FIELD(columns);
1805 0 : READ_NODE_FIELD(on_error);
1806 0 : READ_NODE_FIELD(alias);
1807 0 : READ_BOOL_FIELD(lateral);
1808 0 : READ_LOCATION_FIELD(location);
1809 :
1810 0 : READ_DONE();
1811 : }
1812 :
1813 : static JsonTableColumn *
1814 0 : _readJsonTableColumn(void)
1815 : {
1816 0 : READ_LOCALS(JsonTableColumn);
1817 :
1818 0 : READ_ENUM_FIELD(coltype, JsonTableColumnType);
1819 0 : READ_STRING_FIELD(name);
1820 0 : READ_NODE_FIELD(typeName);
1821 0 : READ_NODE_FIELD(pathspec);
1822 0 : READ_NODE_FIELD(format);
1823 0 : READ_ENUM_FIELD(wrapper, JsonWrapper);
1824 0 : READ_ENUM_FIELD(quotes, JsonQuotes);
1825 0 : READ_NODE_FIELD(columns);
1826 0 : READ_NODE_FIELD(on_empty);
1827 0 : READ_NODE_FIELD(on_error);
1828 0 : READ_LOCATION_FIELD(location);
1829 :
1830 0 : READ_DONE();
1831 : }
1832 :
1833 : static JsonKeyValue *
1834 0 : _readJsonKeyValue(void)
1835 : {
1836 0 : READ_LOCALS(JsonKeyValue);
1837 :
1838 0 : READ_NODE_FIELD(key);
1839 0 : READ_NODE_FIELD(value);
1840 :
1841 0 : READ_DONE();
1842 : }
1843 :
1844 : static JsonParseExpr *
1845 0 : _readJsonParseExpr(void)
1846 : {
1847 0 : READ_LOCALS(JsonParseExpr);
1848 :
1849 0 : READ_NODE_FIELD(expr);
1850 0 : READ_NODE_FIELD(output);
1851 0 : READ_BOOL_FIELD(unique_keys);
1852 0 : READ_LOCATION_FIELD(location);
1853 :
1854 0 : READ_DONE();
1855 : }
1856 :
1857 : static JsonScalarExpr *
1858 0 : _readJsonScalarExpr(void)
1859 : {
1860 0 : READ_LOCALS(JsonScalarExpr);
1861 :
1862 0 : READ_NODE_FIELD(expr);
1863 0 : READ_NODE_FIELD(output);
1864 0 : READ_LOCATION_FIELD(location);
1865 :
1866 0 : READ_DONE();
1867 : }
1868 :
1869 : static JsonSerializeExpr *
1870 0 : _readJsonSerializeExpr(void)
1871 : {
1872 0 : READ_LOCALS(JsonSerializeExpr);
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 JsonObjectConstructor *
1882 0 : _readJsonObjectConstructor(void)
1883 : {
1884 0 : READ_LOCALS(JsonObjectConstructor);
1885 :
1886 0 : READ_NODE_FIELD(exprs);
1887 0 : READ_NODE_FIELD(output);
1888 0 : READ_BOOL_FIELD(absent_on_null);
1889 0 : READ_BOOL_FIELD(unique);
1890 0 : READ_LOCATION_FIELD(location);
1891 :
1892 0 : READ_DONE();
1893 : }
1894 :
1895 : static JsonArrayConstructor *
1896 0 : _readJsonArrayConstructor(void)
1897 : {
1898 0 : READ_LOCALS(JsonArrayConstructor);
1899 :
1900 0 : READ_NODE_FIELD(exprs);
1901 0 : READ_NODE_FIELD(output);
1902 0 : READ_BOOL_FIELD(absent_on_null);
1903 0 : READ_LOCATION_FIELD(location);
1904 :
1905 0 : READ_DONE();
1906 : }
1907 :
1908 : static JsonArrayQueryConstructor *
1909 0 : _readJsonArrayQueryConstructor(void)
1910 : {
1911 0 : READ_LOCALS(JsonArrayQueryConstructor);
1912 :
1913 0 : READ_NODE_FIELD(query);
1914 0 : READ_NODE_FIELD(output);
1915 0 : READ_NODE_FIELD(format);
1916 0 : READ_BOOL_FIELD(absent_on_null);
1917 0 : READ_LOCATION_FIELD(location);
1918 :
1919 0 : READ_DONE();
1920 : }
1921 :
1922 : static JsonAggConstructor *
1923 0 : _readJsonAggConstructor(void)
1924 : {
1925 0 : READ_LOCALS(JsonAggConstructor);
1926 :
1927 0 : READ_NODE_FIELD(output);
1928 0 : READ_NODE_FIELD(agg_filter);
1929 0 : READ_NODE_FIELD(agg_order);
1930 0 : READ_NODE_FIELD(over);
1931 0 : READ_LOCATION_FIELD(location);
1932 :
1933 0 : READ_DONE();
1934 : }
1935 :
1936 : static JsonObjectAgg *
1937 0 : _readJsonObjectAgg(void)
1938 : {
1939 0 : READ_LOCALS(JsonObjectAgg);
1940 :
1941 0 : READ_NODE_FIELD(constructor);
1942 0 : READ_NODE_FIELD(arg);
1943 0 : READ_BOOL_FIELD(absent_on_null);
1944 0 : READ_BOOL_FIELD(unique);
1945 :
1946 0 : READ_DONE();
1947 : }
1948 :
1949 : static JsonArrayAgg *
1950 0 : _readJsonArrayAgg(void)
1951 : {
1952 0 : READ_LOCALS(JsonArrayAgg);
1953 :
1954 0 : READ_NODE_FIELD(constructor);
1955 0 : READ_NODE_FIELD(arg);
1956 0 : READ_BOOL_FIELD(absent_on_null);
1957 :
1958 0 : READ_DONE();
1959 : }
1960 :
1961 : static RawStmt *
1962 0 : _readRawStmt(void)
1963 : {
1964 0 : READ_LOCALS(RawStmt);
1965 :
1966 0 : READ_NODE_FIELD(stmt);
1967 0 : READ_LOCATION_FIELD(stmt_location);
1968 0 : READ_LOCATION_FIELD(stmt_len);
1969 :
1970 0 : READ_DONE();
1971 : }
1972 :
1973 : static InsertStmt *
1974 0 : _readInsertStmt(void)
1975 : {
1976 0 : READ_LOCALS(InsertStmt);
1977 :
1978 0 : READ_NODE_FIELD(relation);
1979 0 : READ_NODE_FIELD(cols);
1980 0 : READ_NODE_FIELD(selectStmt);
1981 0 : READ_NODE_FIELD(onConflictClause);
1982 0 : READ_NODE_FIELD(returningClause);
1983 0 : READ_NODE_FIELD(withClause);
1984 0 : READ_ENUM_FIELD(override, OverridingKind);
1985 :
1986 0 : READ_DONE();
1987 : }
1988 :
1989 : static DeleteStmt *
1990 0 : _readDeleteStmt(void)
1991 : {
1992 0 : READ_LOCALS(DeleteStmt);
1993 :
1994 0 : READ_NODE_FIELD(relation);
1995 0 : READ_NODE_FIELD(usingClause);
1996 0 : READ_NODE_FIELD(whereClause);
1997 0 : READ_NODE_FIELD(returningClause);
1998 0 : READ_NODE_FIELD(withClause);
1999 :
2000 0 : READ_DONE();
2001 : }
2002 :
2003 : static UpdateStmt *
2004 0 : _readUpdateStmt(void)
2005 : {
2006 0 : READ_LOCALS(UpdateStmt);
2007 :
2008 0 : READ_NODE_FIELD(relation);
2009 0 : READ_NODE_FIELD(targetList);
2010 0 : READ_NODE_FIELD(whereClause);
2011 0 : READ_NODE_FIELD(fromClause);
2012 0 : READ_NODE_FIELD(returningClause);
2013 0 : READ_NODE_FIELD(withClause);
2014 :
2015 0 : READ_DONE();
2016 : }
2017 :
2018 : static MergeStmt *
2019 0 : _readMergeStmt(void)
2020 : {
2021 0 : READ_LOCALS(MergeStmt);
2022 :
2023 0 : READ_NODE_FIELD(relation);
2024 0 : READ_NODE_FIELD(sourceRelation);
2025 0 : READ_NODE_FIELD(joinCondition);
2026 0 : READ_NODE_FIELD(mergeWhenClauses);
2027 0 : READ_NODE_FIELD(returningClause);
2028 0 : READ_NODE_FIELD(withClause);
2029 :
2030 0 : READ_DONE();
2031 : }
2032 :
2033 : static SelectStmt *
2034 0 : _readSelectStmt(void)
2035 : {
2036 0 : READ_LOCALS(SelectStmt);
2037 :
2038 0 : READ_NODE_FIELD(distinctClause);
2039 0 : READ_NODE_FIELD(intoClause);
2040 0 : READ_NODE_FIELD(targetList);
2041 0 : READ_NODE_FIELD(fromClause);
2042 0 : READ_NODE_FIELD(whereClause);
2043 0 : READ_NODE_FIELD(groupClause);
2044 0 : READ_BOOL_FIELD(groupDistinct);
2045 0 : READ_BOOL_FIELD(groupByAll);
2046 0 : READ_NODE_FIELD(havingClause);
2047 0 : READ_NODE_FIELD(windowClause);
2048 0 : READ_NODE_FIELD(valuesLists);
2049 0 : READ_NODE_FIELD(sortClause);
2050 0 : READ_NODE_FIELD(limitOffset);
2051 0 : READ_NODE_FIELD(limitCount);
2052 0 : READ_ENUM_FIELD(limitOption, LimitOption);
2053 0 : READ_NODE_FIELD(lockingClause);
2054 0 : READ_NODE_FIELD(withClause);
2055 0 : READ_ENUM_FIELD(op, SetOperation);
2056 0 : READ_BOOL_FIELD(all);
2057 0 : READ_NODE_FIELD(larg);
2058 0 : READ_NODE_FIELD(rarg);
2059 :
2060 0 : READ_DONE();
2061 : }
2062 :
2063 : static SetOperationStmt *
2064 10642 : _readSetOperationStmt(void)
2065 : {
2066 10642 : READ_LOCALS(SetOperationStmt);
2067 :
2068 10642 : READ_ENUM_FIELD(op, SetOperation);
2069 10642 : READ_BOOL_FIELD(all);
2070 10642 : READ_NODE_FIELD(larg);
2071 10642 : READ_NODE_FIELD(rarg);
2072 10642 : READ_NODE_FIELD(colTypes);
2073 10642 : READ_NODE_FIELD(colTypmods);
2074 10642 : READ_NODE_FIELD(colCollations);
2075 10642 : READ_NODE_FIELD(groupClauses);
2076 :
2077 10642 : READ_DONE();
2078 : }
2079 :
2080 : static ReturnStmt *
2081 0 : _readReturnStmt(void)
2082 : {
2083 0 : READ_LOCALS(ReturnStmt);
2084 :
2085 0 : READ_NODE_FIELD(returnval);
2086 :
2087 0 : READ_DONE();
2088 : }
2089 :
2090 : static PLAssignStmt *
2091 0 : _readPLAssignStmt(void)
2092 : {
2093 0 : READ_LOCALS(PLAssignStmt);
2094 :
2095 0 : READ_STRING_FIELD(name);
2096 0 : READ_NODE_FIELD(indirection);
2097 0 : READ_INT_FIELD(nnames);
2098 0 : READ_NODE_FIELD(val);
2099 0 : READ_LOCATION_FIELD(location);
2100 :
2101 0 : READ_DONE();
2102 : }
2103 :
2104 : static CreateSchemaStmt *
2105 0 : _readCreateSchemaStmt(void)
2106 : {
2107 0 : READ_LOCALS(CreateSchemaStmt);
2108 :
2109 0 : READ_STRING_FIELD(schemaname);
2110 0 : READ_NODE_FIELD(authrole);
2111 0 : READ_NODE_FIELD(schemaElts);
2112 0 : READ_BOOL_FIELD(if_not_exists);
2113 :
2114 0 : READ_DONE();
2115 : }
2116 :
2117 : static AlterTableStmt *
2118 0 : _readAlterTableStmt(void)
2119 : {
2120 0 : READ_LOCALS(AlterTableStmt);
2121 :
2122 0 : READ_NODE_FIELD(relation);
2123 0 : READ_NODE_FIELD(cmds);
2124 0 : READ_ENUM_FIELD(objtype, ObjectType);
2125 0 : READ_BOOL_FIELD(missing_ok);
2126 :
2127 0 : READ_DONE();
2128 : }
2129 :
2130 : static AlterTableCmd *
2131 0 : _readAlterTableCmd(void)
2132 : {
2133 0 : READ_LOCALS(AlterTableCmd);
2134 :
2135 0 : READ_ENUM_FIELD(subtype, AlterTableType);
2136 0 : READ_STRING_FIELD(name);
2137 0 : READ_INT_FIELD(num);
2138 0 : READ_NODE_FIELD(newowner);
2139 0 : READ_NODE_FIELD(def);
2140 0 : READ_ENUM_FIELD(behavior, DropBehavior);
2141 0 : READ_BOOL_FIELD(missing_ok);
2142 0 : READ_BOOL_FIELD(recurse);
2143 :
2144 0 : READ_DONE();
2145 : }
2146 :
2147 : static ATAlterConstraint *
2148 0 : _readATAlterConstraint(void)
2149 : {
2150 0 : READ_LOCALS(ATAlterConstraint);
2151 :
2152 0 : READ_STRING_FIELD(conname);
2153 0 : READ_BOOL_FIELD(alterEnforceability);
2154 0 : READ_BOOL_FIELD(is_enforced);
2155 0 : READ_BOOL_FIELD(alterDeferrability);
2156 0 : READ_BOOL_FIELD(deferrable);
2157 0 : READ_BOOL_FIELD(initdeferred);
2158 0 : READ_BOOL_FIELD(alterInheritability);
2159 0 : READ_BOOL_FIELD(noinherit);
2160 :
2161 0 : READ_DONE();
2162 : }
2163 :
2164 : static ReplicaIdentityStmt *
2165 0 : _readReplicaIdentityStmt(void)
2166 : {
2167 0 : READ_LOCALS(ReplicaIdentityStmt);
2168 :
2169 0 : READ_CHAR_FIELD(identity_type);
2170 0 : READ_STRING_FIELD(name);
2171 :
2172 0 : READ_DONE();
2173 : }
2174 :
2175 : static AlterCollationStmt *
2176 0 : _readAlterCollationStmt(void)
2177 : {
2178 0 : READ_LOCALS(AlterCollationStmt);
2179 :
2180 0 : READ_NODE_FIELD(collname);
2181 :
2182 0 : READ_DONE();
2183 : }
2184 :
2185 : static AlterDomainStmt *
2186 0 : _readAlterDomainStmt(void)
2187 : {
2188 0 : READ_LOCALS(AlterDomainStmt);
2189 :
2190 0 : READ_ENUM_FIELD(subtype, AlterDomainType);
2191 0 : READ_NODE_FIELD(typeName);
2192 0 : READ_STRING_FIELD(name);
2193 0 : READ_NODE_FIELD(def);
2194 0 : READ_ENUM_FIELD(behavior, DropBehavior);
2195 0 : READ_BOOL_FIELD(missing_ok);
2196 :
2197 0 : READ_DONE();
2198 : }
2199 :
2200 : static GrantStmt *
2201 0 : _readGrantStmt(void)
2202 : {
2203 0 : READ_LOCALS(GrantStmt);
2204 :
2205 0 : READ_BOOL_FIELD(is_grant);
2206 0 : READ_ENUM_FIELD(targtype, GrantTargetType);
2207 0 : READ_ENUM_FIELD(objtype, ObjectType);
2208 0 : READ_NODE_FIELD(objects);
2209 0 : READ_NODE_FIELD(privileges);
2210 0 : READ_NODE_FIELD(grantees);
2211 0 : READ_BOOL_FIELD(grant_option);
2212 0 : READ_NODE_FIELD(grantor);
2213 0 : READ_ENUM_FIELD(behavior, DropBehavior);
2214 :
2215 0 : READ_DONE();
2216 : }
2217 :
2218 : static ObjectWithArgs *
2219 0 : _readObjectWithArgs(void)
2220 : {
2221 0 : READ_LOCALS(ObjectWithArgs);
2222 :
2223 0 : READ_NODE_FIELD(objname);
2224 0 : READ_NODE_FIELD(objargs);
2225 0 : READ_NODE_FIELD(objfuncargs);
2226 0 : READ_BOOL_FIELD(args_unspecified);
2227 :
2228 0 : READ_DONE();
2229 : }
2230 :
2231 : static AccessPriv *
2232 0 : _readAccessPriv(void)
2233 : {
2234 0 : READ_LOCALS(AccessPriv);
2235 :
2236 0 : READ_STRING_FIELD(priv_name);
2237 0 : READ_NODE_FIELD(cols);
2238 :
2239 0 : READ_DONE();
2240 : }
2241 :
2242 : static GrantRoleStmt *
2243 0 : _readGrantRoleStmt(void)
2244 : {
2245 0 : READ_LOCALS(GrantRoleStmt);
2246 :
2247 0 : READ_NODE_FIELD(granted_roles);
2248 0 : READ_NODE_FIELD(grantee_roles);
2249 0 : READ_BOOL_FIELD(is_grant);
2250 0 : READ_NODE_FIELD(opt);
2251 0 : READ_NODE_FIELD(grantor);
2252 0 : READ_ENUM_FIELD(behavior, DropBehavior);
2253 :
2254 0 : READ_DONE();
2255 : }
2256 :
2257 : static AlterDefaultPrivilegesStmt *
2258 0 : _readAlterDefaultPrivilegesStmt(void)
2259 : {
2260 0 : READ_LOCALS(AlterDefaultPrivilegesStmt);
2261 :
2262 0 : READ_NODE_FIELD(options);
2263 0 : READ_NODE_FIELD(action);
2264 :
2265 0 : READ_DONE();
2266 : }
2267 :
2268 : static CopyStmt *
2269 0 : _readCopyStmt(void)
2270 : {
2271 0 : READ_LOCALS(CopyStmt);
2272 :
2273 0 : READ_NODE_FIELD(relation);
2274 0 : READ_NODE_FIELD(query);
2275 0 : READ_NODE_FIELD(attlist);
2276 0 : READ_BOOL_FIELD(is_from);
2277 0 : READ_BOOL_FIELD(is_program);
2278 0 : READ_STRING_FIELD(filename);
2279 0 : READ_NODE_FIELD(options);
2280 0 : READ_NODE_FIELD(whereClause);
2281 :
2282 0 : READ_DONE();
2283 : }
2284 :
2285 : static VariableSetStmt *
2286 0 : _readVariableSetStmt(void)
2287 : {
2288 0 : READ_LOCALS(VariableSetStmt);
2289 :
2290 0 : READ_ENUM_FIELD(kind, VariableSetKind);
2291 0 : READ_STRING_FIELD(name);
2292 0 : READ_NODE_FIELD(args);
2293 0 : READ_BOOL_FIELD(jumble_args);
2294 0 : READ_BOOL_FIELD(is_local);
2295 0 : READ_LOCATION_FIELD(location);
2296 :
2297 0 : READ_DONE();
2298 : }
2299 :
2300 : static VariableShowStmt *
2301 0 : _readVariableShowStmt(void)
2302 : {
2303 0 : READ_LOCALS(VariableShowStmt);
2304 :
2305 0 : READ_STRING_FIELD(name);
2306 :
2307 0 : READ_DONE();
2308 : }
2309 :
2310 : static CreateStmt *
2311 0 : _readCreateStmt(void)
2312 : {
2313 0 : READ_LOCALS(CreateStmt);
2314 :
2315 0 : READ_NODE_FIELD(relation);
2316 0 : READ_NODE_FIELD(tableElts);
2317 0 : READ_NODE_FIELD(inhRelations);
2318 0 : READ_NODE_FIELD(partbound);
2319 0 : READ_NODE_FIELD(partspec);
2320 0 : READ_NODE_FIELD(ofTypename);
2321 0 : READ_NODE_FIELD(constraints);
2322 0 : READ_NODE_FIELD(nnconstraints);
2323 0 : READ_NODE_FIELD(options);
2324 0 : READ_ENUM_FIELD(oncommit, OnCommitAction);
2325 0 : READ_STRING_FIELD(tablespacename);
2326 0 : READ_STRING_FIELD(accessMethod);
2327 0 : READ_BOOL_FIELD(if_not_exists);
2328 :
2329 0 : READ_DONE();
2330 : }
2331 :
2332 : static Constraint *
2333 0 : _readConstraint(void)
2334 : {
2335 0 : READ_LOCALS(Constraint);
2336 :
2337 0 : READ_ENUM_FIELD(contype, ConstrType);
2338 0 : READ_STRING_FIELD(conname);
2339 0 : READ_BOOL_FIELD(deferrable);
2340 0 : READ_BOOL_FIELD(initdeferred);
2341 0 : READ_BOOL_FIELD(is_enforced);
2342 0 : READ_BOOL_FIELD(skip_validation);
2343 0 : READ_BOOL_FIELD(initially_valid);
2344 0 : READ_BOOL_FIELD(is_no_inherit);
2345 0 : READ_NODE_FIELD(raw_expr);
2346 0 : READ_STRING_FIELD(cooked_expr);
2347 0 : READ_CHAR_FIELD(generated_when);
2348 0 : READ_CHAR_FIELD(generated_kind);
2349 0 : READ_BOOL_FIELD(nulls_not_distinct);
2350 0 : READ_NODE_FIELD(keys);
2351 0 : READ_BOOL_FIELD(without_overlaps);
2352 0 : READ_NODE_FIELD(including);
2353 0 : READ_NODE_FIELD(exclusions);
2354 0 : READ_NODE_FIELD(options);
2355 0 : READ_STRING_FIELD(indexname);
2356 0 : READ_STRING_FIELD(indexspace);
2357 0 : READ_BOOL_FIELD(reset_default_tblspc);
2358 0 : READ_STRING_FIELD(access_method);
2359 0 : READ_NODE_FIELD(where_clause);
2360 0 : READ_NODE_FIELD(pktable);
2361 0 : READ_NODE_FIELD(fk_attrs);
2362 0 : READ_NODE_FIELD(pk_attrs);
2363 0 : READ_BOOL_FIELD(fk_with_period);
2364 0 : READ_BOOL_FIELD(pk_with_period);
2365 0 : READ_CHAR_FIELD(fk_matchtype);
2366 0 : READ_CHAR_FIELD(fk_upd_action);
2367 0 : READ_CHAR_FIELD(fk_del_action);
2368 0 : READ_NODE_FIELD(fk_del_set_cols);
2369 0 : READ_NODE_FIELD(old_conpfeqop);
2370 0 : READ_OID_FIELD(old_pktable_oid);
2371 0 : READ_LOCATION_FIELD(location);
2372 :
2373 0 : READ_DONE();
2374 : }
2375 :
2376 : static CreateTableSpaceStmt *
2377 0 : _readCreateTableSpaceStmt(void)
2378 : {
2379 0 : READ_LOCALS(CreateTableSpaceStmt);
2380 :
2381 0 : READ_STRING_FIELD(tablespacename);
2382 0 : READ_NODE_FIELD(owner);
2383 0 : READ_STRING_FIELD(location);
2384 0 : READ_NODE_FIELD(options);
2385 :
2386 0 : READ_DONE();
2387 : }
2388 :
2389 : static DropTableSpaceStmt *
2390 0 : _readDropTableSpaceStmt(void)
2391 : {
2392 0 : READ_LOCALS(DropTableSpaceStmt);
2393 :
2394 0 : READ_STRING_FIELD(tablespacename);
2395 0 : READ_BOOL_FIELD(missing_ok);
2396 :
2397 0 : READ_DONE();
2398 : }
2399 :
2400 : static AlterTableSpaceOptionsStmt *
2401 0 : _readAlterTableSpaceOptionsStmt(void)
2402 : {
2403 0 : READ_LOCALS(AlterTableSpaceOptionsStmt);
2404 :
2405 0 : READ_STRING_FIELD(tablespacename);
2406 0 : READ_NODE_FIELD(options);
2407 0 : READ_BOOL_FIELD(isReset);
2408 :
2409 0 : READ_DONE();
2410 : }
2411 :
2412 : static AlterTableMoveAllStmt *
2413 0 : _readAlterTableMoveAllStmt(void)
2414 : {
2415 0 : READ_LOCALS(AlterTableMoveAllStmt);
2416 :
2417 0 : READ_STRING_FIELD(orig_tablespacename);
2418 0 : READ_ENUM_FIELD(objtype, ObjectType);
2419 0 : READ_NODE_FIELD(roles);
2420 0 : READ_STRING_FIELD(new_tablespacename);
2421 0 : READ_BOOL_FIELD(nowait);
2422 :
2423 0 : READ_DONE();
2424 : }
2425 :
2426 : static CreateExtensionStmt *
2427 0 : _readCreateExtensionStmt(void)
2428 : {
2429 0 : READ_LOCALS(CreateExtensionStmt);
2430 :
2431 0 : READ_STRING_FIELD(extname);
2432 0 : READ_BOOL_FIELD(if_not_exists);
2433 0 : READ_NODE_FIELD(options);
2434 :
2435 0 : READ_DONE();
2436 : }
2437 :
2438 : static AlterExtensionStmt *
2439 0 : _readAlterExtensionStmt(void)
2440 : {
2441 0 : READ_LOCALS(AlterExtensionStmt);
2442 :
2443 0 : READ_STRING_FIELD(extname);
2444 0 : READ_NODE_FIELD(options);
2445 :
2446 0 : READ_DONE();
2447 : }
2448 :
2449 : static AlterExtensionContentsStmt *
2450 0 : _readAlterExtensionContentsStmt(void)
2451 : {
2452 0 : READ_LOCALS(AlterExtensionContentsStmt);
2453 :
2454 0 : READ_STRING_FIELD(extname);
2455 0 : READ_INT_FIELD(action);
2456 0 : READ_ENUM_FIELD(objtype, ObjectType);
2457 0 : READ_NODE_FIELD(object);
2458 :
2459 0 : READ_DONE();
2460 : }
2461 :
2462 : static CreateFdwStmt *
2463 0 : _readCreateFdwStmt(void)
2464 : {
2465 0 : READ_LOCALS(CreateFdwStmt);
2466 :
2467 0 : READ_STRING_FIELD(fdwname);
2468 0 : READ_NODE_FIELD(func_options);
2469 0 : READ_NODE_FIELD(options);
2470 :
2471 0 : READ_DONE();
2472 : }
2473 :
2474 : static AlterFdwStmt *
2475 0 : _readAlterFdwStmt(void)
2476 : {
2477 0 : READ_LOCALS(AlterFdwStmt);
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 CreateForeignServerStmt *
2487 0 : _readCreateForeignServerStmt(void)
2488 : {
2489 0 : READ_LOCALS(CreateForeignServerStmt);
2490 :
2491 0 : READ_STRING_FIELD(servername);
2492 0 : READ_STRING_FIELD(servertype);
2493 0 : READ_STRING_FIELD(version);
2494 0 : READ_STRING_FIELD(fdwname);
2495 0 : READ_BOOL_FIELD(if_not_exists);
2496 0 : READ_NODE_FIELD(options);
2497 :
2498 0 : READ_DONE();
2499 : }
2500 :
2501 : static AlterForeignServerStmt *
2502 0 : _readAlterForeignServerStmt(void)
2503 : {
2504 0 : READ_LOCALS(AlterForeignServerStmt);
2505 :
2506 0 : READ_STRING_FIELD(servername);
2507 0 : READ_STRING_FIELD(version);
2508 0 : READ_NODE_FIELD(options);
2509 0 : READ_BOOL_FIELD(has_version);
2510 :
2511 0 : READ_DONE();
2512 : }
2513 :
2514 : static CreateForeignTableStmt *
2515 0 : _readCreateForeignTableStmt(void)
2516 : {
2517 0 : READ_LOCALS(CreateForeignTableStmt);
2518 :
2519 0 : READ_NODE_FIELD(base.relation);
2520 0 : READ_NODE_FIELD(base.tableElts);
2521 0 : READ_NODE_FIELD(base.inhRelations);
2522 0 : READ_NODE_FIELD(base.partbound);
2523 0 : READ_NODE_FIELD(base.partspec);
2524 0 : READ_NODE_FIELD(base.ofTypename);
2525 0 : READ_NODE_FIELD(base.constraints);
2526 0 : READ_NODE_FIELD(base.nnconstraints);
2527 0 : READ_NODE_FIELD(base.options);
2528 0 : READ_ENUM_FIELD(base.oncommit, OnCommitAction);
2529 0 : READ_STRING_FIELD(base.tablespacename);
2530 0 : READ_STRING_FIELD(base.accessMethod);
2531 0 : READ_BOOL_FIELD(base.if_not_exists);
2532 0 : READ_STRING_FIELD(servername);
2533 0 : READ_NODE_FIELD(options);
2534 :
2535 0 : READ_DONE();
2536 : }
2537 :
2538 : static CreateUserMappingStmt *
2539 0 : _readCreateUserMappingStmt(void)
2540 : {
2541 0 : READ_LOCALS(CreateUserMappingStmt);
2542 :
2543 0 : READ_NODE_FIELD(user);
2544 0 : READ_STRING_FIELD(servername);
2545 0 : READ_BOOL_FIELD(if_not_exists);
2546 0 : READ_NODE_FIELD(options);
2547 :
2548 0 : READ_DONE();
2549 : }
2550 :
2551 : static AlterUserMappingStmt *
2552 0 : _readAlterUserMappingStmt(void)
2553 : {
2554 0 : READ_LOCALS(AlterUserMappingStmt);
2555 :
2556 0 : READ_NODE_FIELD(user);
2557 0 : READ_STRING_FIELD(servername);
2558 0 : READ_NODE_FIELD(options);
2559 :
2560 0 : READ_DONE();
2561 : }
2562 :
2563 : static DropUserMappingStmt *
2564 0 : _readDropUserMappingStmt(void)
2565 : {
2566 0 : READ_LOCALS(DropUserMappingStmt);
2567 :
2568 0 : READ_NODE_FIELD(user);
2569 0 : READ_STRING_FIELD(servername);
2570 0 : READ_BOOL_FIELD(missing_ok);
2571 :
2572 0 : READ_DONE();
2573 : }
2574 :
2575 : static ImportForeignSchemaStmt *
2576 0 : _readImportForeignSchemaStmt(void)
2577 : {
2578 0 : READ_LOCALS(ImportForeignSchemaStmt);
2579 :
2580 0 : READ_STRING_FIELD(server_name);
2581 0 : READ_STRING_FIELD(remote_schema);
2582 0 : READ_STRING_FIELD(local_schema);
2583 0 : READ_ENUM_FIELD(list_type, ImportForeignSchemaType);
2584 0 : READ_NODE_FIELD(table_list);
2585 0 : READ_NODE_FIELD(options);
2586 :
2587 0 : READ_DONE();
2588 : }
2589 :
2590 : static CreatePolicyStmt *
2591 0 : _readCreatePolicyStmt(void)
2592 : {
2593 0 : READ_LOCALS(CreatePolicyStmt);
2594 :
2595 0 : READ_STRING_FIELD(policy_name);
2596 0 : READ_NODE_FIELD(table);
2597 0 : READ_STRING_FIELD(cmd_name);
2598 0 : READ_BOOL_FIELD(permissive);
2599 0 : READ_NODE_FIELD(roles);
2600 0 : READ_NODE_FIELD(qual);
2601 0 : READ_NODE_FIELD(with_check);
2602 :
2603 0 : READ_DONE();
2604 : }
2605 :
2606 : static AlterPolicyStmt *
2607 0 : _readAlterPolicyStmt(void)
2608 : {
2609 0 : READ_LOCALS(AlterPolicyStmt);
2610 :
2611 0 : READ_STRING_FIELD(policy_name);
2612 0 : READ_NODE_FIELD(table);
2613 0 : READ_NODE_FIELD(roles);
2614 0 : READ_NODE_FIELD(qual);
2615 0 : READ_NODE_FIELD(with_check);
2616 :
2617 0 : READ_DONE();
2618 : }
2619 :
2620 : static CreateAmStmt *
2621 0 : _readCreateAmStmt(void)
2622 : {
2623 0 : READ_LOCALS(CreateAmStmt);
2624 :
2625 0 : READ_STRING_FIELD(amname);
2626 0 : READ_NODE_FIELD(handler_name);
2627 0 : READ_CHAR_FIELD(amtype);
2628 :
2629 0 : READ_DONE();
2630 : }
2631 :
2632 : static CreateTrigStmt *
2633 0 : _readCreateTrigStmt(void)
2634 : {
2635 0 : READ_LOCALS(CreateTrigStmt);
2636 :
2637 0 : READ_BOOL_FIELD(replace);
2638 0 : READ_BOOL_FIELD(isconstraint);
2639 0 : READ_STRING_FIELD(trigname);
2640 0 : READ_NODE_FIELD(relation);
2641 0 : READ_NODE_FIELD(funcname);
2642 0 : READ_NODE_FIELD(args);
2643 0 : READ_BOOL_FIELD(row);
2644 0 : READ_INT_FIELD(timing);
2645 0 : READ_INT_FIELD(events);
2646 0 : READ_NODE_FIELD(columns);
2647 0 : READ_NODE_FIELD(whenClause);
2648 0 : READ_NODE_FIELD(transitionRels);
2649 0 : READ_BOOL_FIELD(deferrable);
2650 0 : READ_BOOL_FIELD(initdeferred);
2651 0 : READ_NODE_FIELD(constrrel);
2652 :
2653 0 : READ_DONE();
2654 : }
2655 :
2656 : static CreateEventTrigStmt *
2657 0 : _readCreateEventTrigStmt(void)
2658 : {
2659 0 : READ_LOCALS(CreateEventTrigStmt);
2660 :
2661 0 : READ_STRING_FIELD(trigname);
2662 0 : READ_STRING_FIELD(eventname);
2663 0 : READ_NODE_FIELD(whenclause);
2664 0 : READ_NODE_FIELD(funcname);
2665 :
2666 0 : READ_DONE();
2667 : }
2668 :
2669 : static AlterEventTrigStmt *
2670 0 : _readAlterEventTrigStmt(void)
2671 : {
2672 0 : READ_LOCALS(AlterEventTrigStmt);
2673 :
2674 0 : READ_STRING_FIELD(trigname);
2675 0 : READ_CHAR_FIELD(tgenabled);
2676 :
2677 0 : READ_DONE();
2678 : }
2679 :
2680 : static CreatePLangStmt *
2681 0 : _readCreatePLangStmt(void)
2682 : {
2683 0 : READ_LOCALS(CreatePLangStmt);
2684 :
2685 0 : READ_BOOL_FIELD(replace);
2686 0 : READ_STRING_FIELD(plname);
2687 0 : READ_NODE_FIELD(plhandler);
2688 0 : READ_NODE_FIELD(plinline);
2689 0 : READ_NODE_FIELD(plvalidator);
2690 0 : READ_BOOL_FIELD(pltrusted);
2691 :
2692 0 : READ_DONE();
2693 : }
2694 :
2695 : static CreateRoleStmt *
2696 0 : _readCreateRoleStmt(void)
2697 : {
2698 0 : READ_LOCALS(CreateRoleStmt);
2699 :
2700 0 : READ_ENUM_FIELD(stmt_type, RoleStmtType);
2701 0 : READ_STRING_FIELD(role);
2702 0 : READ_NODE_FIELD(options);
2703 :
2704 0 : READ_DONE();
2705 : }
2706 :
2707 : static AlterRoleStmt *
2708 0 : _readAlterRoleStmt(void)
2709 : {
2710 0 : READ_LOCALS(AlterRoleStmt);
2711 :
2712 0 : READ_NODE_FIELD(role);
2713 0 : READ_NODE_FIELD(options);
2714 0 : READ_INT_FIELD(action);
2715 :
2716 0 : READ_DONE();
2717 : }
2718 :
2719 : static AlterRoleSetStmt *
2720 0 : _readAlterRoleSetStmt(void)
2721 : {
2722 0 : READ_LOCALS(AlterRoleSetStmt);
2723 :
2724 0 : READ_NODE_FIELD(role);
2725 0 : READ_STRING_FIELD(database);
2726 0 : READ_NODE_FIELD(setstmt);
2727 :
2728 0 : READ_DONE();
2729 : }
2730 :
2731 : static DropRoleStmt *
2732 0 : _readDropRoleStmt(void)
2733 : {
2734 0 : READ_LOCALS(DropRoleStmt);
2735 :
2736 0 : READ_NODE_FIELD(roles);
2737 0 : READ_BOOL_FIELD(missing_ok);
2738 :
2739 0 : READ_DONE();
2740 : }
2741 :
2742 : static CreateSeqStmt *
2743 0 : _readCreateSeqStmt(void)
2744 : {
2745 0 : READ_LOCALS(CreateSeqStmt);
2746 :
2747 0 : READ_NODE_FIELD(sequence);
2748 0 : READ_NODE_FIELD(options);
2749 0 : READ_OID_FIELD(ownerId);
2750 0 : READ_BOOL_FIELD(for_identity);
2751 0 : READ_BOOL_FIELD(if_not_exists);
2752 :
2753 0 : READ_DONE();
2754 : }
2755 :
2756 : static AlterSeqStmt *
2757 0 : _readAlterSeqStmt(void)
2758 : {
2759 0 : READ_LOCALS(AlterSeqStmt);
2760 :
2761 0 : READ_NODE_FIELD(sequence);
2762 0 : READ_NODE_FIELD(options);
2763 0 : READ_BOOL_FIELD(for_identity);
2764 0 : READ_BOOL_FIELD(missing_ok);
2765 :
2766 0 : READ_DONE();
2767 : }
2768 :
2769 : static DefineStmt *
2770 0 : _readDefineStmt(void)
2771 : {
2772 0 : READ_LOCALS(DefineStmt);
2773 :
2774 0 : READ_ENUM_FIELD(kind, ObjectType);
2775 0 : READ_BOOL_FIELD(oldstyle);
2776 0 : READ_NODE_FIELD(defnames);
2777 0 : READ_NODE_FIELD(args);
2778 0 : READ_NODE_FIELD(definition);
2779 0 : READ_BOOL_FIELD(if_not_exists);
2780 0 : READ_BOOL_FIELD(replace);
2781 :
2782 0 : READ_DONE();
2783 : }
2784 :
2785 : static CreateDomainStmt *
2786 0 : _readCreateDomainStmt(void)
2787 : {
2788 0 : READ_LOCALS(CreateDomainStmt);
2789 :
2790 0 : READ_NODE_FIELD(domainname);
2791 0 : READ_NODE_FIELD(typeName);
2792 0 : READ_NODE_FIELD(collClause);
2793 0 : READ_NODE_FIELD(constraints);
2794 :
2795 0 : READ_DONE();
2796 : }
2797 :
2798 : static CreateOpClassStmt *
2799 0 : _readCreateOpClassStmt(void)
2800 : {
2801 0 : READ_LOCALS(CreateOpClassStmt);
2802 :
2803 0 : READ_NODE_FIELD(opclassname);
2804 0 : READ_NODE_FIELD(opfamilyname);
2805 0 : READ_STRING_FIELD(amname);
2806 0 : READ_NODE_FIELD(datatype);
2807 0 : READ_NODE_FIELD(items);
2808 0 : READ_BOOL_FIELD(isDefault);
2809 :
2810 0 : READ_DONE();
2811 : }
2812 :
2813 : static CreateOpClassItem *
2814 0 : _readCreateOpClassItem(void)
2815 : {
2816 0 : READ_LOCALS(CreateOpClassItem);
2817 :
2818 0 : READ_INT_FIELD(itemtype);
2819 0 : READ_NODE_FIELD(name);
2820 0 : READ_INT_FIELD(number);
2821 0 : READ_NODE_FIELD(order_family);
2822 0 : READ_NODE_FIELD(class_args);
2823 0 : READ_NODE_FIELD(storedtype);
2824 :
2825 0 : READ_DONE();
2826 : }
2827 :
2828 : static CreateOpFamilyStmt *
2829 0 : _readCreateOpFamilyStmt(void)
2830 : {
2831 0 : READ_LOCALS(CreateOpFamilyStmt);
2832 :
2833 0 : READ_NODE_FIELD(opfamilyname);
2834 0 : READ_STRING_FIELD(amname);
2835 :
2836 0 : READ_DONE();
2837 : }
2838 :
2839 : static AlterOpFamilyStmt *
2840 0 : _readAlterOpFamilyStmt(void)
2841 : {
2842 0 : READ_LOCALS(AlterOpFamilyStmt);
2843 :
2844 0 : READ_NODE_FIELD(opfamilyname);
2845 0 : READ_STRING_FIELD(amname);
2846 0 : READ_BOOL_FIELD(isDrop);
2847 0 : READ_NODE_FIELD(items);
2848 :
2849 0 : READ_DONE();
2850 : }
2851 :
2852 : static DropStmt *
2853 0 : _readDropStmt(void)
2854 : {
2855 0 : READ_LOCALS(DropStmt);
2856 :
2857 0 : READ_NODE_FIELD(objects);
2858 0 : READ_ENUM_FIELD(removeType, ObjectType);
2859 0 : READ_ENUM_FIELD(behavior, DropBehavior);
2860 0 : READ_BOOL_FIELD(missing_ok);
2861 0 : READ_BOOL_FIELD(concurrent);
2862 :
2863 0 : READ_DONE();
2864 : }
2865 :
2866 : static TruncateStmt *
2867 0 : _readTruncateStmt(void)
2868 : {
2869 0 : READ_LOCALS(TruncateStmt);
2870 :
2871 0 : READ_NODE_FIELD(relations);
2872 0 : READ_BOOL_FIELD(restart_seqs);
2873 0 : READ_ENUM_FIELD(behavior, DropBehavior);
2874 :
2875 0 : READ_DONE();
2876 : }
2877 :
2878 : static CommentStmt *
2879 0 : _readCommentStmt(void)
2880 : {
2881 0 : READ_LOCALS(CommentStmt);
2882 :
2883 0 : READ_ENUM_FIELD(objtype, ObjectType);
2884 0 : READ_NODE_FIELD(object);
2885 0 : READ_STRING_FIELD(comment);
2886 :
2887 0 : READ_DONE();
2888 : }
2889 :
2890 : static SecLabelStmt *
2891 0 : _readSecLabelStmt(void)
2892 : {
2893 0 : READ_LOCALS(SecLabelStmt);
2894 :
2895 0 : READ_ENUM_FIELD(objtype, ObjectType);
2896 0 : READ_NODE_FIELD(object);
2897 0 : READ_STRING_FIELD(provider);
2898 0 : READ_STRING_FIELD(label);
2899 :
2900 0 : READ_DONE();
2901 : }
2902 :
2903 : static DeclareCursorStmt *
2904 0 : _readDeclareCursorStmt(void)
2905 : {
2906 0 : READ_LOCALS(DeclareCursorStmt);
2907 :
2908 0 : READ_STRING_FIELD(portalname);
2909 0 : READ_INT_FIELD(options);
2910 0 : READ_NODE_FIELD(query);
2911 :
2912 0 : READ_DONE();
2913 : }
2914 :
2915 : static ClosePortalStmt *
2916 0 : _readClosePortalStmt(void)
2917 : {
2918 0 : READ_LOCALS(ClosePortalStmt);
2919 :
2920 0 : READ_STRING_FIELD(portalname);
2921 :
2922 0 : READ_DONE();
2923 : }
2924 :
2925 : static FetchStmt *
2926 0 : _readFetchStmt(void)
2927 : {
2928 0 : READ_LOCALS(FetchStmt);
2929 :
2930 0 : READ_ENUM_FIELD(direction, FetchDirection);
2931 0 : READ_LONG_FIELD(howMany);
2932 0 : READ_STRING_FIELD(portalname);
2933 0 : READ_BOOL_FIELD(ismove);
2934 0 : READ_ENUM_FIELD(direction_keyword, FetchDirectionKeywords);
2935 0 : READ_LOCATION_FIELD(location);
2936 :
2937 0 : READ_DONE();
2938 : }
2939 :
2940 : static IndexStmt *
2941 0 : _readIndexStmt(void)
2942 : {
2943 0 : READ_LOCALS(IndexStmt);
2944 :
2945 0 : READ_STRING_FIELD(idxname);
2946 0 : READ_NODE_FIELD(relation);
2947 0 : READ_STRING_FIELD(accessMethod);
2948 0 : READ_STRING_FIELD(tableSpace);
2949 0 : READ_NODE_FIELD(indexParams);
2950 0 : READ_NODE_FIELD(indexIncludingParams);
2951 0 : READ_NODE_FIELD(options);
2952 0 : READ_NODE_FIELD(whereClause);
2953 0 : READ_NODE_FIELD(excludeOpNames);
2954 0 : READ_STRING_FIELD(idxcomment);
2955 0 : READ_OID_FIELD(indexOid);
2956 0 : READ_OID_FIELD(oldNumber);
2957 0 : READ_UINT_FIELD(oldCreateSubid);
2958 0 : READ_UINT_FIELD(oldFirstRelfilelocatorSubid);
2959 0 : READ_BOOL_FIELD(unique);
2960 0 : READ_BOOL_FIELD(nulls_not_distinct);
2961 0 : READ_BOOL_FIELD(primary);
2962 0 : READ_BOOL_FIELD(isconstraint);
2963 0 : READ_BOOL_FIELD(iswithoutoverlaps);
2964 0 : READ_BOOL_FIELD(deferrable);
2965 0 : READ_BOOL_FIELD(initdeferred);
2966 0 : READ_BOOL_FIELD(transformed);
2967 0 : READ_BOOL_FIELD(concurrent);
2968 0 : READ_BOOL_FIELD(if_not_exists);
2969 0 : READ_BOOL_FIELD(reset_default_tblspc);
2970 :
2971 0 : READ_DONE();
2972 : }
2973 :
2974 : static CreateStatsStmt *
2975 0 : _readCreateStatsStmt(void)
2976 : {
2977 0 : READ_LOCALS(CreateStatsStmt);
2978 :
2979 0 : READ_NODE_FIELD(defnames);
2980 0 : READ_NODE_FIELD(stat_types);
2981 0 : READ_NODE_FIELD(exprs);
2982 0 : READ_NODE_FIELD(relations);
2983 0 : READ_STRING_FIELD(stxcomment);
2984 0 : READ_BOOL_FIELD(transformed);
2985 0 : READ_BOOL_FIELD(if_not_exists);
2986 :
2987 0 : READ_DONE();
2988 : }
2989 :
2990 : static StatsElem *
2991 0 : _readStatsElem(void)
2992 : {
2993 0 : READ_LOCALS(StatsElem);
2994 :
2995 0 : READ_STRING_FIELD(name);
2996 0 : READ_NODE_FIELD(expr);
2997 :
2998 0 : READ_DONE();
2999 : }
3000 :
3001 : static AlterStatsStmt *
3002 0 : _readAlterStatsStmt(void)
3003 : {
3004 0 : READ_LOCALS(AlterStatsStmt);
3005 :
3006 0 : READ_NODE_FIELD(defnames);
3007 0 : READ_NODE_FIELD(stxstattarget);
3008 0 : READ_BOOL_FIELD(missing_ok);
3009 :
3010 0 : READ_DONE();
3011 : }
3012 :
3013 : static CreateFunctionStmt *
3014 0 : _readCreateFunctionStmt(void)
3015 : {
3016 0 : READ_LOCALS(CreateFunctionStmt);
3017 :
3018 0 : READ_BOOL_FIELD(is_procedure);
3019 0 : READ_BOOL_FIELD(replace);
3020 0 : READ_NODE_FIELD(funcname);
3021 0 : READ_NODE_FIELD(parameters);
3022 0 : READ_NODE_FIELD(returnType);
3023 0 : READ_NODE_FIELD(options);
3024 0 : READ_NODE_FIELD(sql_body);
3025 :
3026 0 : READ_DONE();
3027 : }
3028 :
3029 : static FunctionParameter *
3030 0 : _readFunctionParameter(void)
3031 : {
3032 0 : READ_LOCALS(FunctionParameter);
3033 :
3034 0 : READ_STRING_FIELD(name);
3035 0 : READ_NODE_FIELD(argType);
3036 0 : READ_ENUM_FIELD(mode, FunctionParameterMode);
3037 0 : READ_NODE_FIELD(defexpr);
3038 0 : READ_LOCATION_FIELD(location);
3039 :
3040 0 : READ_DONE();
3041 : }
3042 :
3043 : static AlterFunctionStmt *
3044 0 : _readAlterFunctionStmt(void)
3045 : {
3046 0 : READ_LOCALS(AlterFunctionStmt);
3047 :
3048 0 : READ_ENUM_FIELD(objtype, ObjectType);
3049 0 : READ_NODE_FIELD(func);
3050 0 : READ_NODE_FIELD(actions);
3051 :
3052 0 : READ_DONE();
3053 : }
3054 :
3055 : static DoStmt *
3056 0 : _readDoStmt(void)
3057 : {
3058 0 : READ_LOCALS(DoStmt);
3059 :
3060 0 : READ_NODE_FIELD(args);
3061 :
3062 0 : READ_DONE();
3063 : }
3064 :
3065 : static CallStmt *
3066 0 : _readCallStmt(void)
3067 : {
3068 0 : READ_LOCALS(CallStmt);
3069 :
3070 0 : READ_NODE_FIELD(funccall);
3071 0 : READ_NODE_FIELD(funcexpr);
3072 0 : READ_NODE_FIELD(outargs);
3073 :
3074 0 : READ_DONE();
3075 : }
3076 :
3077 : static RenameStmt *
3078 0 : _readRenameStmt(void)
3079 : {
3080 0 : READ_LOCALS(RenameStmt);
3081 :
3082 0 : READ_ENUM_FIELD(renameType, ObjectType);
3083 0 : READ_ENUM_FIELD(relationType, ObjectType);
3084 0 : READ_NODE_FIELD(relation);
3085 0 : READ_NODE_FIELD(object);
3086 0 : READ_STRING_FIELD(subname);
3087 0 : READ_STRING_FIELD(newname);
3088 0 : READ_ENUM_FIELD(behavior, DropBehavior);
3089 0 : READ_BOOL_FIELD(missing_ok);
3090 :
3091 0 : READ_DONE();
3092 : }
3093 :
3094 : static AlterObjectDependsStmt *
3095 0 : _readAlterObjectDependsStmt(void)
3096 : {
3097 0 : READ_LOCALS(AlterObjectDependsStmt);
3098 :
3099 0 : READ_ENUM_FIELD(objectType, ObjectType);
3100 0 : READ_NODE_FIELD(relation);
3101 0 : READ_NODE_FIELD(object);
3102 0 : READ_NODE_FIELD(extname);
3103 0 : READ_BOOL_FIELD(remove);
3104 :
3105 0 : READ_DONE();
3106 : }
3107 :
3108 : static AlterObjectSchemaStmt *
3109 0 : _readAlterObjectSchemaStmt(void)
3110 : {
3111 0 : READ_LOCALS(AlterObjectSchemaStmt);
3112 :
3113 0 : READ_ENUM_FIELD(objectType, ObjectType);
3114 0 : READ_NODE_FIELD(relation);
3115 0 : READ_NODE_FIELD(object);
3116 0 : READ_STRING_FIELD(newschema);
3117 0 : READ_BOOL_FIELD(missing_ok);
3118 :
3119 0 : READ_DONE();
3120 : }
3121 :
3122 : static AlterOwnerStmt *
3123 0 : _readAlterOwnerStmt(void)
3124 : {
3125 0 : READ_LOCALS(AlterOwnerStmt);
3126 :
3127 0 : READ_ENUM_FIELD(objectType, ObjectType);
3128 0 : READ_NODE_FIELD(relation);
3129 0 : READ_NODE_FIELD(object);
3130 0 : READ_NODE_FIELD(newowner);
3131 :
3132 0 : READ_DONE();
3133 : }
3134 :
3135 : static AlterOperatorStmt *
3136 0 : _readAlterOperatorStmt(void)
3137 : {
3138 0 : READ_LOCALS(AlterOperatorStmt);
3139 :
3140 0 : READ_NODE_FIELD(opername);
3141 0 : READ_NODE_FIELD(options);
3142 :
3143 0 : READ_DONE();
3144 : }
3145 :
3146 : static AlterTypeStmt *
3147 0 : _readAlterTypeStmt(void)
3148 : {
3149 0 : READ_LOCALS(AlterTypeStmt);
3150 :
3151 0 : READ_NODE_FIELD(typeName);
3152 0 : READ_NODE_FIELD(options);
3153 :
3154 0 : READ_DONE();
3155 : }
3156 :
3157 : static RuleStmt *
3158 0 : _readRuleStmt(void)
3159 : {
3160 0 : READ_LOCALS(RuleStmt);
3161 :
3162 0 : READ_NODE_FIELD(relation);
3163 0 : READ_STRING_FIELD(rulename);
3164 0 : READ_NODE_FIELD(whereClause);
3165 0 : READ_ENUM_FIELD(event, CmdType);
3166 0 : READ_BOOL_FIELD(instead);
3167 0 : READ_NODE_FIELD(actions);
3168 0 : READ_BOOL_FIELD(replace);
3169 :
3170 0 : READ_DONE();
3171 : }
3172 :
3173 : static NotifyStmt *
3174 126 : _readNotifyStmt(void)
3175 : {
3176 126 : READ_LOCALS(NotifyStmt);
3177 :
3178 126 : READ_STRING_FIELD(conditionname);
3179 126 : READ_STRING_FIELD(payload);
3180 :
3181 126 : READ_DONE();
3182 : }
3183 :
3184 : static ListenStmt *
3185 0 : _readListenStmt(void)
3186 : {
3187 0 : READ_LOCALS(ListenStmt);
3188 :
3189 0 : READ_STRING_FIELD(conditionname);
3190 :
3191 0 : READ_DONE();
3192 : }
3193 :
3194 : static UnlistenStmt *
3195 0 : _readUnlistenStmt(void)
3196 : {
3197 0 : READ_LOCALS(UnlistenStmt);
3198 :
3199 0 : READ_STRING_FIELD(conditionname);
3200 :
3201 0 : READ_DONE();
3202 : }
3203 :
3204 : static TransactionStmt *
3205 0 : _readTransactionStmt(void)
3206 : {
3207 0 : READ_LOCALS(TransactionStmt);
3208 :
3209 0 : READ_ENUM_FIELD(kind, TransactionStmtKind);
3210 0 : READ_NODE_FIELD(options);
3211 0 : READ_STRING_FIELD(savepoint_name);
3212 0 : READ_STRING_FIELD(gid);
3213 0 : READ_BOOL_FIELD(chain);
3214 0 : READ_LOCATION_FIELD(location);
3215 :
3216 0 : READ_DONE();
3217 : }
3218 :
3219 : static CompositeTypeStmt *
3220 0 : _readCompositeTypeStmt(void)
3221 : {
3222 0 : READ_LOCALS(CompositeTypeStmt);
3223 :
3224 0 : READ_NODE_FIELD(typevar);
3225 0 : READ_NODE_FIELD(coldeflist);
3226 :
3227 0 : READ_DONE();
3228 : }
3229 :
3230 : static CreateEnumStmt *
3231 0 : _readCreateEnumStmt(void)
3232 : {
3233 0 : READ_LOCALS(CreateEnumStmt);
3234 :
3235 0 : READ_NODE_FIELD(typeName);
3236 0 : READ_NODE_FIELD(vals);
3237 :
3238 0 : READ_DONE();
3239 : }
3240 :
3241 : static CreateRangeStmt *
3242 0 : _readCreateRangeStmt(void)
3243 : {
3244 0 : READ_LOCALS(CreateRangeStmt);
3245 :
3246 0 : READ_NODE_FIELD(typeName);
3247 0 : READ_NODE_FIELD(params);
3248 :
3249 0 : READ_DONE();
3250 : }
3251 :
3252 : static AlterEnumStmt *
3253 0 : _readAlterEnumStmt(void)
3254 : {
3255 0 : READ_LOCALS(AlterEnumStmt);
3256 :
3257 0 : READ_NODE_FIELD(typeName);
3258 0 : READ_STRING_FIELD(oldVal);
3259 0 : READ_STRING_FIELD(newVal);
3260 0 : READ_STRING_FIELD(newValNeighbor);
3261 0 : READ_BOOL_FIELD(newValIsAfter);
3262 0 : READ_BOOL_FIELD(skipIfNewValExists);
3263 :
3264 0 : READ_DONE();
3265 : }
3266 :
3267 : static ViewStmt *
3268 0 : _readViewStmt(void)
3269 : {
3270 0 : READ_LOCALS(ViewStmt);
3271 :
3272 0 : READ_NODE_FIELD(view);
3273 0 : READ_NODE_FIELD(aliases);
3274 0 : READ_NODE_FIELD(query);
3275 0 : READ_BOOL_FIELD(replace);
3276 0 : READ_NODE_FIELD(options);
3277 0 : READ_ENUM_FIELD(withCheckOption, ViewCheckOption);
3278 :
3279 0 : READ_DONE();
3280 : }
3281 :
3282 : static LoadStmt *
3283 0 : _readLoadStmt(void)
3284 : {
3285 0 : READ_LOCALS(LoadStmt);
3286 :
3287 0 : READ_STRING_FIELD(filename);
3288 :
3289 0 : READ_DONE();
3290 : }
3291 :
3292 : static CreatedbStmt *
3293 0 : _readCreatedbStmt(void)
3294 : {
3295 0 : READ_LOCALS(CreatedbStmt);
3296 :
3297 0 : READ_STRING_FIELD(dbname);
3298 0 : READ_NODE_FIELD(options);
3299 :
3300 0 : READ_DONE();
3301 : }
3302 :
3303 : static AlterDatabaseStmt *
3304 0 : _readAlterDatabaseStmt(void)
3305 : {
3306 0 : READ_LOCALS(AlterDatabaseStmt);
3307 :
3308 0 : READ_STRING_FIELD(dbname);
3309 0 : READ_NODE_FIELD(options);
3310 :
3311 0 : READ_DONE();
3312 : }
3313 :
3314 : static AlterDatabaseRefreshCollStmt *
3315 0 : _readAlterDatabaseRefreshCollStmt(void)
3316 : {
3317 0 : READ_LOCALS(AlterDatabaseRefreshCollStmt);
3318 :
3319 0 : READ_STRING_FIELD(dbname);
3320 :
3321 0 : READ_DONE();
3322 : }
3323 :
3324 : static AlterDatabaseSetStmt *
3325 0 : _readAlterDatabaseSetStmt(void)
3326 : {
3327 0 : READ_LOCALS(AlterDatabaseSetStmt);
3328 :
3329 0 : READ_STRING_FIELD(dbname);
3330 0 : READ_NODE_FIELD(setstmt);
3331 :
3332 0 : READ_DONE();
3333 : }
3334 :
3335 : static DropdbStmt *
3336 0 : _readDropdbStmt(void)
3337 : {
3338 0 : READ_LOCALS(DropdbStmt);
3339 :
3340 0 : READ_STRING_FIELD(dbname);
3341 0 : READ_BOOL_FIELD(missing_ok);
3342 0 : READ_NODE_FIELD(options);
3343 :
3344 0 : READ_DONE();
3345 : }
3346 :
3347 : static AlterSystemStmt *
3348 0 : _readAlterSystemStmt(void)
3349 : {
3350 0 : READ_LOCALS(AlterSystemStmt);
3351 :
3352 0 : READ_NODE_FIELD(setstmt);
3353 :
3354 0 : READ_DONE();
3355 : }
3356 :
3357 : static ClusterStmt *
3358 0 : _readClusterStmt(void)
3359 : {
3360 0 : READ_LOCALS(ClusterStmt);
3361 :
3362 0 : READ_NODE_FIELD(relation);
3363 0 : READ_STRING_FIELD(indexname);
3364 0 : READ_NODE_FIELD(params);
3365 :
3366 0 : READ_DONE();
3367 : }
3368 :
3369 : static VacuumStmt *
3370 0 : _readVacuumStmt(void)
3371 : {
3372 0 : READ_LOCALS(VacuumStmt);
3373 :
3374 0 : READ_NODE_FIELD(options);
3375 0 : READ_NODE_FIELD(rels);
3376 0 : READ_BOOL_FIELD(is_vacuumcmd);
3377 :
3378 0 : READ_DONE();
3379 : }
3380 :
3381 : static VacuumRelation *
3382 0 : _readVacuumRelation(void)
3383 : {
3384 0 : READ_LOCALS(VacuumRelation);
3385 :
3386 0 : READ_NODE_FIELD(relation);
3387 0 : READ_OID_FIELD(oid);
3388 0 : READ_NODE_FIELD(va_cols);
3389 :
3390 0 : READ_DONE();
3391 : }
3392 :
3393 : static ExplainStmt *
3394 0 : _readExplainStmt(void)
3395 : {
3396 0 : READ_LOCALS(ExplainStmt);
3397 :
3398 0 : READ_NODE_FIELD(query);
3399 0 : READ_NODE_FIELD(options);
3400 :
3401 0 : READ_DONE();
3402 : }
3403 :
3404 : static CreateTableAsStmt *
3405 0 : _readCreateTableAsStmt(void)
3406 : {
3407 0 : READ_LOCALS(CreateTableAsStmt);
3408 :
3409 0 : READ_NODE_FIELD(query);
3410 0 : READ_NODE_FIELD(into);
3411 0 : READ_ENUM_FIELD(objtype, ObjectType);
3412 0 : READ_BOOL_FIELD(is_select_into);
3413 0 : READ_BOOL_FIELD(if_not_exists);
3414 :
3415 0 : READ_DONE();
3416 : }
3417 :
3418 : static RefreshMatViewStmt *
3419 0 : _readRefreshMatViewStmt(void)
3420 : {
3421 0 : READ_LOCALS(RefreshMatViewStmt);
3422 :
3423 0 : READ_BOOL_FIELD(concurrent);
3424 0 : READ_BOOL_FIELD(skipData);
3425 0 : READ_NODE_FIELD(relation);
3426 :
3427 0 : READ_DONE();
3428 : }
3429 :
3430 : static CheckPointStmt *
3431 0 : _readCheckPointStmt(void)
3432 : {
3433 0 : READ_LOCALS(CheckPointStmt);
3434 :
3435 0 : READ_NODE_FIELD(options);
3436 :
3437 0 : READ_DONE();
3438 : }
3439 :
3440 : static DiscardStmt *
3441 0 : _readDiscardStmt(void)
3442 : {
3443 0 : READ_LOCALS(DiscardStmt);
3444 :
3445 0 : READ_ENUM_FIELD(target, DiscardMode);
3446 :
3447 0 : READ_DONE();
3448 : }
3449 :
3450 : static LockStmt *
3451 0 : _readLockStmt(void)
3452 : {
3453 0 : READ_LOCALS(LockStmt);
3454 :
3455 0 : READ_NODE_FIELD(relations);
3456 0 : READ_INT_FIELD(mode);
3457 0 : READ_BOOL_FIELD(nowait);
3458 :
3459 0 : READ_DONE();
3460 : }
3461 :
3462 : static ConstraintsSetStmt *
3463 0 : _readConstraintsSetStmt(void)
3464 : {
3465 0 : READ_LOCALS(ConstraintsSetStmt);
3466 :
3467 0 : READ_NODE_FIELD(constraints);
3468 0 : READ_BOOL_FIELD(deferred);
3469 :
3470 0 : READ_DONE();
3471 : }
3472 :
3473 : static ReindexStmt *
3474 0 : _readReindexStmt(void)
3475 : {
3476 0 : READ_LOCALS(ReindexStmt);
3477 :
3478 0 : READ_ENUM_FIELD(kind, ReindexObjectType);
3479 0 : READ_NODE_FIELD(relation);
3480 0 : READ_STRING_FIELD(name);
3481 0 : READ_NODE_FIELD(params);
3482 :
3483 0 : READ_DONE();
3484 : }
3485 :
3486 : static CreateConversionStmt *
3487 0 : _readCreateConversionStmt(void)
3488 : {
3489 0 : READ_LOCALS(CreateConversionStmt);
3490 :
3491 0 : READ_NODE_FIELD(conversion_name);
3492 0 : READ_STRING_FIELD(for_encoding_name);
3493 0 : READ_STRING_FIELD(to_encoding_name);
3494 0 : READ_NODE_FIELD(func_name);
3495 0 : READ_BOOL_FIELD(def);
3496 :
3497 0 : READ_DONE();
3498 : }
3499 :
3500 : static CreateCastStmt *
3501 0 : _readCreateCastStmt(void)
3502 : {
3503 0 : READ_LOCALS(CreateCastStmt);
3504 :
3505 0 : READ_NODE_FIELD(sourcetype);
3506 0 : READ_NODE_FIELD(targettype);
3507 0 : READ_NODE_FIELD(func);
3508 0 : READ_ENUM_FIELD(context, CoercionContext);
3509 0 : READ_BOOL_FIELD(inout);
3510 :
3511 0 : READ_DONE();
3512 : }
3513 :
3514 : static CreateTransformStmt *
3515 0 : _readCreateTransformStmt(void)
3516 : {
3517 0 : READ_LOCALS(CreateTransformStmt);
3518 :
3519 0 : READ_BOOL_FIELD(replace);
3520 0 : READ_NODE_FIELD(type_name);
3521 0 : READ_STRING_FIELD(lang);
3522 0 : READ_NODE_FIELD(fromsql);
3523 0 : READ_NODE_FIELD(tosql);
3524 :
3525 0 : READ_DONE();
3526 : }
3527 :
3528 : static PrepareStmt *
3529 0 : _readPrepareStmt(void)
3530 : {
3531 0 : READ_LOCALS(PrepareStmt);
3532 :
3533 0 : READ_STRING_FIELD(name);
3534 0 : READ_NODE_FIELD(argtypes);
3535 0 : READ_NODE_FIELD(query);
3536 :
3537 0 : READ_DONE();
3538 : }
3539 :
3540 : static ExecuteStmt *
3541 0 : _readExecuteStmt(void)
3542 : {
3543 0 : READ_LOCALS(ExecuteStmt);
3544 :
3545 0 : READ_STRING_FIELD(name);
3546 0 : READ_NODE_FIELD(params);
3547 :
3548 0 : READ_DONE();
3549 : }
3550 :
3551 : static DeallocateStmt *
3552 0 : _readDeallocateStmt(void)
3553 : {
3554 0 : READ_LOCALS(DeallocateStmt);
3555 :
3556 0 : READ_STRING_FIELD(name);
3557 0 : READ_BOOL_FIELD(isall);
3558 0 : READ_LOCATION_FIELD(location);
3559 :
3560 0 : READ_DONE();
3561 : }
3562 :
3563 : static DropOwnedStmt *
3564 0 : _readDropOwnedStmt(void)
3565 : {
3566 0 : READ_LOCALS(DropOwnedStmt);
3567 :
3568 0 : READ_NODE_FIELD(roles);
3569 0 : READ_ENUM_FIELD(behavior, DropBehavior);
3570 :
3571 0 : READ_DONE();
3572 : }
3573 :
3574 : static ReassignOwnedStmt *
3575 0 : _readReassignOwnedStmt(void)
3576 : {
3577 0 : READ_LOCALS(ReassignOwnedStmt);
3578 :
3579 0 : READ_NODE_FIELD(roles);
3580 0 : READ_NODE_FIELD(newrole);
3581 :
3582 0 : READ_DONE();
3583 : }
3584 :
3585 : static AlterTSDictionaryStmt *
3586 0 : _readAlterTSDictionaryStmt(void)
3587 : {
3588 0 : READ_LOCALS(AlterTSDictionaryStmt);
3589 :
3590 0 : READ_NODE_FIELD(dictname);
3591 0 : READ_NODE_FIELD(options);
3592 :
3593 0 : READ_DONE();
3594 : }
3595 :
3596 : static AlterTSConfigurationStmt *
3597 0 : _readAlterTSConfigurationStmt(void)
3598 : {
3599 0 : READ_LOCALS(AlterTSConfigurationStmt);
3600 :
3601 0 : READ_ENUM_FIELD(kind, AlterTSConfigType);
3602 0 : READ_NODE_FIELD(cfgname);
3603 0 : READ_NODE_FIELD(tokentype);
3604 0 : READ_NODE_FIELD(dicts);
3605 0 : READ_BOOL_FIELD(override);
3606 0 : READ_BOOL_FIELD(replace);
3607 0 : READ_BOOL_FIELD(missing_ok);
3608 :
3609 0 : READ_DONE();
3610 : }
3611 :
3612 : static PublicationTable *
3613 0 : _readPublicationTable(void)
3614 : {
3615 0 : READ_LOCALS(PublicationTable);
3616 :
3617 0 : READ_NODE_FIELD(relation);
3618 0 : READ_NODE_FIELD(whereClause);
3619 0 : READ_NODE_FIELD(columns);
3620 :
3621 0 : READ_DONE();
3622 : }
3623 :
3624 : static PublicationObjSpec *
3625 0 : _readPublicationObjSpec(void)
3626 : {
3627 0 : READ_LOCALS(PublicationObjSpec);
3628 :
3629 0 : READ_ENUM_FIELD(pubobjtype, PublicationObjSpecType);
3630 0 : READ_STRING_FIELD(name);
3631 0 : READ_NODE_FIELD(pubtable);
3632 0 : READ_LOCATION_FIELD(location);
3633 :
3634 0 : READ_DONE();
3635 : }
3636 :
3637 : static PublicationAllObjSpec *
3638 0 : _readPublicationAllObjSpec(void)
3639 : {
3640 0 : READ_LOCALS(PublicationAllObjSpec);
3641 :
3642 0 : READ_ENUM_FIELD(pubobjtype, PublicationAllObjType);
3643 0 : READ_LOCATION_FIELD(location);
3644 :
3645 0 : READ_DONE();
3646 : }
3647 :
3648 : static CreatePublicationStmt *
3649 0 : _readCreatePublicationStmt(void)
3650 : {
3651 0 : READ_LOCALS(CreatePublicationStmt);
3652 :
3653 0 : READ_STRING_FIELD(pubname);
3654 0 : READ_NODE_FIELD(options);
3655 0 : READ_NODE_FIELD(pubobjects);
3656 0 : READ_BOOL_FIELD(for_all_tables);
3657 0 : READ_BOOL_FIELD(for_all_sequences);
3658 :
3659 0 : READ_DONE();
3660 : }
3661 :
3662 : static AlterPublicationStmt *
3663 0 : _readAlterPublicationStmt(void)
3664 : {
3665 0 : READ_LOCALS(AlterPublicationStmt);
3666 :
3667 0 : READ_STRING_FIELD(pubname);
3668 0 : READ_NODE_FIELD(options);
3669 0 : READ_NODE_FIELD(pubobjects);
3670 0 : READ_ENUM_FIELD(action, AlterPublicationAction);
3671 :
3672 0 : READ_DONE();
3673 : }
3674 :
3675 : static CreateSubscriptionStmt *
3676 0 : _readCreateSubscriptionStmt(void)
3677 : {
3678 0 : READ_LOCALS(CreateSubscriptionStmt);
3679 :
3680 0 : READ_STRING_FIELD(subname);
3681 0 : READ_STRING_FIELD(conninfo);
3682 0 : READ_NODE_FIELD(publication);
3683 0 : READ_NODE_FIELD(options);
3684 :
3685 0 : READ_DONE();
3686 : }
3687 :
3688 : static AlterSubscriptionStmt *
3689 0 : _readAlterSubscriptionStmt(void)
3690 : {
3691 0 : READ_LOCALS(AlterSubscriptionStmt);
3692 :
3693 0 : READ_ENUM_FIELD(kind, AlterSubscriptionType);
3694 0 : READ_STRING_FIELD(subname);
3695 0 : READ_STRING_FIELD(conninfo);
3696 0 : READ_NODE_FIELD(publication);
3697 0 : READ_NODE_FIELD(options);
3698 :
3699 0 : READ_DONE();
3700 : }
3701 :
3702 : static DropSubscriptionStmt *
3703 0 : _readDropSubscriptionStmt(void)
3704 : {
3705 0 : READ_LOCALS(DropSubscriptionStmt);
3706 :
3707 0 : READ_STRING_FIELD(subname);
3708 0 : READ_BOOL_FIELD(missing_ok);
3709 0 : READ_ENUM_FIELD(behavior, DropBehavior);
3710 :
3711 0 : READ_DONE();
3712 : }
3713 :
3714 : static GroupByOrdering *
3715 0 : _readGroupByOrdering(void)
3716 : {
3717 0 : READ_LOCALS(GroupByOrdering);
3718 :
3719 0 : READ_NODE_FIELD(pathkeys);
3720 0 : READ_NODE_FIELD(clauses);
3721 :
3722 0 : READ_DONE();
3723 : }
3724 :
3725 : static PlaceHolderVar *
3726 0 : _readPlaceHolderVar(void)
3727 : {
3728 0 : READ_LOCALS(PlaceHolderVar);
3729 :
3730 0 : READ_NODE_FIELD(phexpr);
3731 0 : READ_BITMAPSET_FIELD(phrels);
3732 0 : READ_BITMAPSET_FIELD(phnullingrels);
3733 0 : READ_UINT_FIELD(phid);
3734 0 : READ_UINT_FIELD(phlevelsup);
3735 :
3736 0 : READ_DONE();
3737 : }
3738 :
3739 : static AppendRelInfo *
3740 0 : _readAppendRelInfo(void)
3741 : {
3742 0 : READ_LOCALS(AppendRelInfo);
3743 :
3744 0 : READ_UINT_FIELD(parent_relid);
3745 0 : READ_UINT_FIELD(child_relid);
3746 0 : READ_OID_FIELD(parent_reltype);
3747 0 : READ_OID_FIELD(child_reltype);
3748 0 : READ_NODE_FIELD(translated_vars);
3749 0 : READ_INT_FIELD(num_child_cols);
3750 0 : READ_ATTRNUMBER_ARRAY(parent_colnos, local_node->num_child_cols);
3751 0 : READ_OID_FIELD(parent_reloid);
3752 :
3753 0 : READ_DONE();
3754 : }
3755 :
3756 : static PlannedStmt *
3757 2536 : _readPlannedStmt(void)
3758 : {
3759 2536 : READ_LOCALS(PlannedStmt);
3760 :
3761 2536 : READ_ENUM_FIELD(commandType, CmdType);
3762 2536 : READ_INT64_FIELD(queryId);
3763 2536 : READ_INT64_FIELD(planId);
3764 2536 : READ_ENUM_FIELD(planOrigin, PlannedStmtOrigin);
3765 2536 : READ_BOOL_FIELD(hasReturning);
3766 2536 : READ_BOOL_FIELD(hasModifyingCTE);
3767 2536 : READ_BOOL_FIELD(canSetTag);
3768 2536 : READ_BOOL_FIELD(transientPlan);
3769 2536 : READ_BOOL_FIELD(dependsOnRole);
3770 2536 : READ_BOOL_FIELD(parallelModeNeeded);
3771 2536 : READ_INT_FIELD(jitFlags);
3772 2536 : READ_NODE_FIELD(planTree);
3773 2536 : READ_NODE_FIELD(partPruneInfos);
3774 2536 : READ_NODE_FIELD(rtable);
3775 2536 : READ_BITMAPSET_FIELD(unprunableRelids);
3776 2536 : READ_NODE_FIELD(permInfos);
3777 2536 : READ_NODE_FIELD(resultRelations);
3778 2536 : READ_NODE_FIELD(appendRelations);
3779 2536 : READ_NODE_FIELD(subplans);
3780 2536 : READ_BITMAPSET_FIELD(rewindPlanIDs);
3781 2536 : READ_NODE_FIELD(rowMarks);
3782 2536 : READ_NODE_FIELD(relationOids);
3783 2536 : READ_NODE_FIELD(invalItems);
3784 2536 : READ_NODE_FIELD(paramExecTypes);
3785 2536 : READ_NODE_FIELD(utilityStmt);
3786 2536 : READ_NODE_FIELD(extension_state);
3787 2536 : READ_LOCATION_FIELD(stmt_location);
3788 2536 : READ_LOCATION_FIELD(stmt_len);
3789 :
3790 2536 : READ_DONE();
3791 : }
3792 :
3793 : static Result *
3794 126 : _readResult(void)
3795 : {
3796 126 : READ_LOCALS(Result);
3797 :
3798 126 : READ_INT_FIELD(plan.disabled_nodes);
3799 126 : READ_FLOAT_FIELD(plan.startup_cost);
3800 126 : READ_FLOAT_FIELD(plan.total_cost);
3801 126 : READ_FLOAT_FIELD(plan.plan_rows);
3802 126 : READ_INT_FIELD(plan.plan_width);
3803 126 : READ_BOOL_FIELD(plan.parallel_aware);
3804 126 : READ_BOOL_FIELD(plan.parallel_safe);
3805 126 : READ_BOOL_FIELD(plan.async_capable);
3806 126 : READ_INT_FIELD(plan.plan_node_id);
3807 126 : READ_NODE_FIELD(plan.targetlist);
3808 126 : READ_NODE_FIELD(plan.qual);
3809 126 : READ_NODE_FIELD(plan.lefttree);
3810 126 : READ_NODE_FIELD(plan.righttree);
3811 126 : READ_NODE_FIELD(plan.initPlan);
3812 126 : READ_BITMAPSET_FIELD(plan.extParam);
3813 126 : READ_BITMAPSET_FIELD(plan.allParam);
3814 126 : READ_ENUM_FIELD(result_type, ResultType);
3815 126 : READ_NODE_FIELD(resconstantqual);
3816 126 : READ_BITMAPSET_FIELD(relids);
3817 :
3818 126 : READ_DONE();
3819 : }
3820 :
3821 : static ProjectSet *
3822 12 : _readProjectSet(void)
3823 : {
3824 12 : READ_LOCALS(ProjectSet);
3825 :
3826 12 : READ_INT_FIELD(plan.disabled_nodes);
3827 12 : READ_FLOAT_FIELD(plan.startup_cost);
3828 12 : READ_FLOAT_FIELD(plan.total_cost);
3829 12 : READ_FLOAT_FIELD(plan.plan_rows);
3830 12 : READ_INT_FIELD(plan.plan_width);
3831 12 : READ_BOOL_FIELD(plan.parallel_aware);
3832 12 : READ_BOOL_FIELD(plan.parallel_safe);
3833 12 : READ_BOOL_FIELD(plan.async_capable);
3834 12 : READ_INT_FIELD(plan.plan_node_id);
3835 12 : READ_NODE_FIELD(plan.targetlist);
3836 12 : READ_NODE_FIELD(plan.qual);
3837 12 : READ_NODE_FIELD(plan.lefttree);
3838 12 : READ_NODE_FIELD(plan.righttree);
3839 12 : READ_NODE_FIELD(plan.initPlan);
3840 12 : READ_BITMAPSET_FIELD(plan.extParam);
3841 12 : READ_BITMAPSET_FIELD(plan.allParam);
3842 :
3843 12 : READ_DONE();
3844 : }
3845 :
3846 : static ModifyTable *
3847 0 : _readModifyTable(void)
3848 : {
3849 0 : READ_LOCALS(ModifyTable);
3850 :
3851 0 : READ_INT_FIELD(plan.disabled_nodes);
3852 0 : READ_FLOAT_FIELD(plan.startup_cost);
3853 0 : READ_FLOAT_FIELD(plan.total_cost);
3854 0 : READ_FLOAT_FIELD(plan.plan_rows);
3855 0 : READ_INT_FIELD(plan.plan_width);
3856 0 : READ_BOOL_FIELD(plan.parallel_aware);
3857 0 : READ_BOOL_FIELD(plan.parallel_safe);
3858 0 : READ_BOOL_FIELD(plan.async_capable);
3859 0 : READ_INT_FIELD(plan.plan_node_id);
3860 0 : READ_NODE_FIELD(plan.targetlist);
3861 0 : READ_NODE_FIELD(plan.qual);
3862 0 : READ_NODE_FIELD(plan.lefttree);
3863 0 : READ_NODE_FIELD(plan.righttree);
3864 0 : READ_NODE_FIELD(plan.initPlan);
3865 0 : READ_BITMAPSET_FIELD(plan.extParam);
3866 0 : READ_BITMAPSET_FIELD(plan.allParam);
3867 0 : READ_ENUM_FIELD(operation, CmdType);
3868 0 : READ_BOOL_FIELD(canSetTag);
3869 0 : READ_UINT_FIELD(nominalRelation);
3870 0 : READ_UINT_FIELD(rootRelation);
3871 0 : READ_BOOL_FIELD(partColsUpdated);
3872 0 : READ_NODE_FIELD(resultRelations);
3873 0 : READ_NODE_FIELD(updateColnosLists);
3874 0 : READ_NODE_FIELD(withCheckOptionLists);
3875 0 : READ_STRING_FIELD(returningOldAlias);
3876 0 : READ_STRING_FIELD(returningNewAlias);
3877 0 : READ_NODE_FIELD(returningLists);
3878 0 : READ_NODE_FIELD(fdwPrivLists);
3879 0 : READ_BITMAPSET_FIELD(fdwDirectModifyPlans);
3880 0 : READ_NODE_FIELD(rowMarks);
3881 0 : READ_INT_FIELD(epqParam);
3882 0 : READ_ENUM_FIELD(onConflictAction, OnConflictAction);
3883 0 : READ_NODE_FIELD(arbiterIndexes);
3884 0 : READ_NODE_FIELD(onConflictSet);
3885 0 : READ_NODE_FIELD(onConflictCols);
3886 0 : READ_NODE_FIELD(onConflictWhere);
3887 0 : READ_UINT_FIELD(exclRelRTI);
3888 0 : READ_NODE_FIELD(exclRelTlist);
3889 0 : READ_NODE_FIELD(mergeActionLists);
3890 0 : READ_NODE_FIELD(mergeJoinConditions);
3891 :
3892 0 : READ_DONE();
3893 : }
3894 :
3895 : static Append *
3896 374 : _readAppend(void)
3897 : {
3898 374 : READ_LOCALS(Append);
3899 :
3900 374 : READ_INT_FIELD(plan.disabled_nodes);
3901 374 : READ_FLOAT_FIELD(plan.startup_cost);
3902 374 : READ_FLOAT_FIELD(plan.total_cost);
3903 374 : READ_FLOAT_FIELD(plan.plan_rows);
3904 374 : READ_INT_FIELD(plan.plan_width);
3905 374 : READ_BOOL_FIELD(plan.parallel_aware);
3906 374 : READ_BOOL_FIELD(plan.parallel_safe);
3907 374 : READ_BOOL_FIELD(plan.async_capable);
3908 374 : READ_INT_FIELD(plan.plan_node_id);
3909 374 : READ_NODE_FIELD(plan.targetlist);
3910 374 : READ_NODE_FIELD(plan.qual);
3911 374 : READ_NODE_FIELD(plan.lefttree);
3912 374 : READ_NODE_FIELD(plan.righttree);
3913 374 : READ_NODE_FIELD(plan.initPlan);
3914 374 : READ_BITMAPSET_FIELD(plan.extParam);
3915 374 : READ_BITMAPSET_FIELD(plan.allParam);
3916 374 : READ_BITMAPSET_FIELD(apprelids);
3917 374 : READ_NODE_FIELD(appendplans);
3918 374 : READ_INT_FIELD(nasyncplans);
3919 374 : READ_INT_FIELD(first_partial_plan);
3920 374 : READ_INT_FIELD(part_prune_index);
3921 :
3922 374 : READ_DONE();
3923 : }
3924 :
3925 : static MergeAppend *
3926 0 : _readMergeAppend(void)
3927 : {
3928 0 : READ_LOCALS(MergeAppend);
3929 :
3930 0 : READ_INT_FIELD(plan.disabled_nodes);
3931 0 : READ_FLOAT_FIELD(plan.startup_cost);
3932 0 : READ_FLOAT_FIELD(plan.total_cost);
3933 0 : READ_FLOAT_FIELD(plan.plan_rows);
3934 0 : READ_INT_FIELD(plan.plan_width);
3935 0 : READ_BOOL_FIELD(plan.parallel_aware);
3936 0 : READ_BOOL_FIELD(plan.parallel_safe);
3937 0 : READ_BOOL_FIELD(plan.async_capable);
3938 0 : READ_INT_FIELD(plan.plan_node_id);
3939 0 : READ_NODE_FIELD(plan.targetlist);
3940 0 : READ_NODE_FIELD(plan.qual);
3941 0 : READ_NODE_FIELD(plan.lefttree);
3942 0 : READ_NODE_FIELD(plan.righttree);
3943 0 : READ_NODE_FIELD(plan.initPlan);
3944 0 : READ_BITMAPSET_FIELD(plan.extParam);
3945 0 : READ_BITMAPSET_FIELD(plan.allParam);
3946 0 : READ_BITMAPSET_FIELD(apprelids);
3947 0 : READ_NODE_FIELD(mergeplans);
3948 0 : READ_INT_FIELD(numCols);
3949 0 : READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
3950 0 : READ_OID_ARRAY(sortOperators, local_node->numCols);
3951 0 : READ_OID_ARRAY(collations, local_node->numCols);
3952 0 : READ_BOOL_ARRAY(nullsFirst, local_node->numCols);
3953 0 : READ_INT_FIELD(part_prune_index);
3954 :
3955 0 : READ_DONE();
3956 : }
3957 :
3958 : static RecursiveUnion *
3959 0 : _readRecursiveUnion(void)
3960 : {
3961 0 : READ_LOCALS(RecursiveUnion);
3962 :
3963 0 : READ_INT_FIELD(plan.disabled_nodes);
3964 0 : READ_FLOAT_FIELD(plan.startup_cost);
3965 0 : READ_FLOAT_FIELD(plan.total_cost);
3966 0 : READ_FLOAT_FIELD(plan.plan_rows);
3967 0 : READ_INT_FIELD(plan.plan_width);
3968 0 : READ_BOOL_FIELD(plan.parallel_aware);
3969 0 : READ_BOOL_FIELD(plan.parallel_safe);
3970 0 : READ_BOOL_FIELD(plan.async_capable);
3971 0 : READ_INT_FIELD(plan.plan_node_id);
3972 0 : READ_NODE_FIELD(plan.targetlist);
3973 0 : READ_NODE_FIELD(plan.qual);
3974 0 : READ_NODE_FIELD(plan.lefttree);
3975 0 : READ_NODE_FIELD(plan.righttree);
3976 0 : READ_NODE_FIELD(plan.initPlan);
3977 0 : READ_BITMAPSET_FIELD(plan.extParam);
3978 0 : READ_BITMAPSET_FIELD(plan.allParam);
3979 0 : READ_INT_FIELD(wtParam);
3980 0 : READ_INT_FIELD(numCols);
3981 0 : READ_ATTRNUMBER_ARRAY(dupColIdx, local_node->numCols);
3982 0 : READ_OID_ARRAY(dupOperators, local_node->numCols);
3983 0 : READ_OID_ARRAY(dupCollations, local_node->numCols);
3984 0 : READ_LONG_FIELD(numGroups);
3985 :
3986 0 : READ_DONE();
3987 : }
3988 :
3989 : static BitmapAnd *
3990 0 : _readBitmapAnd(void)
3991 : {
3992 0 : READ_LOCALS(BitmapAnd);
3993 :
3994 0 : READ_INT_FIELD(plan.disabled_nodes);
3995 0 : READ_FLOAT_FIELD(plan.startup_cost);
3996 0 : READ_FLOAT_FIELD(plan.total_cost);
3997 0 : READ_FLOAT_FIELD(plan.plan_rows);
3998 0 : READ_INT_FIELD(plan.plan_width);
3999 0 : READ_BOOL_FIELD(plan.parallel_aware);
4000 0 : READ_BOOL_FIELD(plan.parallel_safe);
4001 0 : READ_BOOL_FIELD(plan.async_capable);
4002 0 : READ_INT_FIELD(plan.plan_node_id);
4003 0 : READ_NODE_FIELD(plan.targetlist);
4004 0 : READ_NODE_FIELD(plan.qual);
4005 0 : READ_NODE_FIELD(plan.lefttree);
4006 0 : READ_NODE_FIELD(plan.righttree);
4007 0 : READ_NODE_FIELD(plan.initPlan);
4008 0 : READ_BITMAPSET_FIELD(plan.extParam);
4009 0 : READ_BITMAPSET_FIELD(plan.allParam);
4010 0 : READ_NODE_FIELD(bitmapplans);
4011 :
4012 0 : READ_DONE();
4013 : }
4014 :
4015 : static BitmapOr *
4016 0 : _readBitmapOr(void)
4017 : {
4018 0 : READ_LOCALS(BitmapOr);
4019 :
4020 0 : READ_INT_FIELD(plan.disabled_nodes);
4021 0 : READ_FLOAT_FIELD(plan.startup_cost);
4022 0 : READ_FLOAT_FIELD(plan.total_cost);
4023 0 : READ_FLOAT_FIELD(plan.plan_rows);
4024 0 : READ_INT_FIELD(plan.plan_width);
4025 0 : READ_BOOL_FIELD(plan.parallel_aware);
4026 0 : READ_BOOL_FIELD(plan.parallel_safe);
4027 0 : READ_BOOL_FIELD(plan.async_capable);
4028 0 : READ_INT_FIELD(plan.plan_node_id);
4029 0 : READ_NODE_FIELD(plan.targetlist);
4030 0 : READ_NODE_FIELD(plan.qual);
4031 0 : READ_NODE_FIELD(plan.lefttree);
4032 0 : READ_NODE_FIELD(plan.righttree);
4033 0 : READ_NODE_FIELD(plan.initPlan);
4034 0 : READ_BITMAPSET_FIELD(plan.extParam);
4035 0 : READ_BITMAPSET_FIELD(plan.allParam);
4036 0 : READ_BOOL_FIELD(isshared);
4037 0 : READ_NODE_FIELD(bitmapplans);
4038 :
4039 0 : READ_DONE();
4040 : }
4041 :
4042 : static SeqScan *
4043 3622 : _readSeqScan(void)
4044 : {
4045 3622 : READ_LOCALS(SeqScan);
4046 :
4047 3622 : READ_INT_FIELD(scan.plan.disabled_nodes);
4048 3622 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4049 3622 : READ_FLOAT_FIELD(scan.plan.total_cost);
4050 3622 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4051 3622 : READ_INT_FIELD(scan.plan.plan_width);
4052 3622 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4053 3622 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4054 3622 : READ_BOOL_FIELD(scan.plan.async_capable);
4055 3622 : READ_INT_FIELD(scan.plan.plan_node_id);
4056 3622 : READ_NODE_FIELD(scan.plan.targetlist);
4057 3622 : READ_NODE_FIELD(scan.plan.qual);
4058 3622 : READ_NODE_FIELD(scan.plan.lefttree);
4059 3622 : READ_NODE_FIELD(scan.plan.righttree);
4060 3622 : READ_NODE_FIELD(scan.plan.initPlan);
4061 3622 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4062 3622 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4063 3622 : READ_UINT_FIELD(scan.scanrelid);
4064 :
4065 3622 : READ_DONE();
4066 : }
4067 :
4068 : static SampleScan *
4069 0 : _readSampleScan(void)
4070 : {
4071 0 : READ_LOCALS(SampleScan);
4072 :
4073 0 : READ_INT_FIELD(scan.plan.disabled_nodes);
4074 0 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4075 0 : READ_FLOAT_FIELD(scan.plan.total_cost);
4076 0 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4077 0 : READ_INT_FIELD(scan.plan.plan_width);
4078 0 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4079 0 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4080 0 : READ_BOOL_FIELD(scan.plan.async_capable);
4081 0 : READ_INT_FIELD(scan.plan.plan_node_id);
4082 0 : READ_NODE_FIELD(scan.plan.targetlist);
4083 0 : READ_NODE_FIELD(scan.plan.qual);
4084 0 : READ_NODE_FIELD(scan.plan.lefttree);
4085 0 : READ_NODE_FIELD(scan.plan.righttree);
4086 0 : READ_NODE_FIELD(scan.plan.initPlan);
4087 0 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4088 0 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4089 0 : READ_UINT_FIELD(scan.scanrelid);
4090 0 : READ_NODE_FIELD(tablesample);
4091 :
4092 0 : READ_DONE();
4093 : }
4094 :
4095 : static IndexScan *
4096 396 : _readIndexScan(void)
4097 : {
4098 396 : READ_LOCALS(IndexScan);
4099 :
4100 396 : READ_INT_FIELD(scan.plan.disabled_nodes);
4101 396 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4102 396 : READ_FLOAT_FIELD(scan.plan.total_cost);
4103 396 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4104 396 : READ_INT_FIELD(scan.plan.plan_width);
4105 396 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4106 396 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4107 396 : READ_BOOL_FIELD(scan.plan.async_capable);
4108 396 : READ_INT_FIELD(scan.plan.plan_node_id);
4109 396 : READ_NODE_FIELD(scan.plan.targetlist);
4110 396 : READ_NODE_FIELD(scan.plan.qual);
4111 396 : READ_NODE_FIELD(scan.plan.lefttree);
4112 396 : READ_NODE_FIELD(scan.plan.righttree);
4113 396 : READ_NODE_FIELD(scan.plan.initPlan);
4114 396 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4115 396 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4116 396 : READ_UINT_FIELD(scan.scanrelid);
4117 396 : READ_OID_FIELD(indexid);
4118 396 : READ_NODE_FIELD(indexqual);
4119 396 : READ_NODE_FIELD(indexqualorig);
4120 396 : READ_NODE_FIELD(indexorderby);
4121 396 : READ_NODE_FIELD(indexorderbyorig);
4122 396 : READ_NODE_FIELD(indexorderbyops);
4123 396 : READ_ENUM_FIELD(indexorderdir, ScanDirection);
4124 :
4125 396 : READ_DONE();
4126 : }
4127 :
4128 : static IndexOnlyScan *
4129 242 : _readIndexOnlyScan(void)
4130 : {
4131 242 : READ_LOCALS(IndexOnlyScan);
4132 :
4133 242 : READ_INT_FIELD(scan.plan.disabled_nodes);
4134 242 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4135 242 : READ_FLOAT_FIELD(scan.plan.total_cost);
4136 242 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4137 242 : READ_INT_FIELD(scan.plan.plan_width);
4138 242 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4139 242 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4140 242 : READ_BOOL_FIELD(scan.plan.async_capable);
4141 242 : READ_INT_FIELD(scan.plan.plan_node_id);
4142 242 : READ_NODE_FIELD(scan.plan.targetlist);
4143 242 : READ_NODE_FIELD(scan.plan.qual);
4144 242 : READ_NODE_FIELD(scan.plan.lefttree);
4145 242 : READ_NODE_FIELD(scan.plan.righttree);
4146 242 : READ_NODE_FIELD(scan.plan.initPlan);
4147 242 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4148 242 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4149 242 : READ_UINT_FIELD(scan.scanrelid);
4150 242 : READ_OID_FIELD(indexid);
4151 242 : READ_NODE_FIELD(indexqual);
4152 242 : READ_NODE_FIELD(recheckqual);
4153 242 : READ_NODE_FIELD(indexorderby);
4154 242 : READ_NODE_FIELD(indextlist);
4155 242 : READ_ENUM_FIELD(indexorderdir, ScanDirection);
4156 :
4157 242 : READ_DONE();
4158 : }
4159 :
4160 : static BitmapIndexScan *
4161 270 : _readBitmapIndexScan(void)
4162 : {
4163 270 : READ_LOCALS(BitmapIndexScan);
4164 :
4165 270 : READ_INT_FIELD(scan.plan.disabled_nodes);
4166 270 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4167 270 : READ_FLOAT_FIELD(scan.plan.total_cost);
4168 270 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4169 270 : READ_INT_FIELD(scan.plan.plan_width);
4170 270 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4171 270 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4172 270 : READ_BOOL_FIELD(scan.plan.async_capable);
4173 270 : READ_INT_FIELD(scan.plan.plan_node_id);
4174 270 : READ_NODE_FIELD(scan.plan.targetlist);
4175 270 : READ_NODE_FIELD(scan.plan.qual);
4176 270 : READ_NODE_FIELD(scan.plan.lefttree);
4177 270 : READ_NODE_FIELD(scan.plan.righttree);
4178 270 : READ_NODE_FIELD(scan.plan.initPlan);
4179 270 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4180 270 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4181 270 : READ_UINT_FIELD(scan.scanrelid);
4182 270 : READ_OID_FIELD(indexid);
4183 270 : READ_BOOL_FIELD(isshared);
4184 270 : READ_NODE_FIELD(indexqual);
4185 270 : READ_NODE_FIELD(indexqualorig);
4186 :
4187 270 : READ_DONE();
4188 : }
4189 :
4190 : static BitmapHeapScan *
4191 270 : _readBitmapHeapScan(void)
4192 : {
4193 270 : READ_LOCALS(BitmapHeapScan);
4194 :
4195 270 : READ_INT_FIELD(scan.plan.disabled_nodes);
4196 270 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4197 270 : READ_FLOAT_FIELD(scan.plan.total_cost);
4198 270 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4199 270 : READ_INT_FIELD(scan.plan.plan_width);
4200 270 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4201 270 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4202 270 : READ_BOOL_FIELD(scan.plan.async_capable);
4203 270 : READ_INT_FIELD(scan.plan.plan_node_id);
4204 270 : READ_NODE_FIELD(scan.plan.targetlist);
4205 270 : READ_NODE_FIELD(scan.plan.qual);
4206 270 : READ_NODE_FIELD(scan.plan.lefttree);
4207 270 : READ_NODE_FIELD(scan.plan.righttree);
4208 270 : READ_NODE_FIELD(scan.plan.initPlan);
4209 270 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4210 270 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4211 270 : READ_UINT_FIELD(scan.scanrelid);
4212 270 : READ_NODE_FIELD(bitmapqualorig);
4213 :
4214 270 : READ_DONE();
4215 : }
4216 :
4217 : static TidScan *
4218 0 : _readTidScan(void)
4219 : {
4220 0 : READ_LOCALS(TidScan);
4221 :
4222 0 : READ_INT_FIELD(scan.plan.disabled_nodes);
4223 0 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4224 0 : READ_FLOAT_FIELD(scan.plan.total_cost);
4225 0 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4226 0 : READ_INT_FIELD(scan.plan.plan_width);
4227 0 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4228 0 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4229 0 : READ_BOOL_FIELD(scan.plan.async_capable);
4230 0 : READ_INT_FIELD(scan.plan.plan_node_id);
4231 0 : READ_NODE_FIELD(scan.plan.targetlist);
4232 0 : READ_NODE_FIELD(scan.plan.qual);
4233 0 : READ_NODE_FIELD(scan.plan.lefttree);
4234 0 : READ_NODE_FIELD(scan.plan.righttree);
4235 0 : READ_NODE_FIELD(scan.plan.initPlan);
4236 0 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4237 0 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4238 0 : READ_UINT_FIELD(scan.scanrelid);
4239 0 : READ_NODE_FIELD(tidquals);
4240 :
4241 0 : READ_DONE();
4242 : }
4243 :
4244 : static TidRangeScan *
4245 0 : _readTidRangeScan(void)
4246 : {
4247 0 : READ_LOCALS(TidRangeScan);
4248 :
4249 0 : READ_INT_FIELD(scan.plan.disabled_nodes);
4250 0 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4251 0 : READ_FLOAT_FIELD(scan.plan.total_cost);
4252 0 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4253 0 : READ_INT_FIELD(scan.plan.plan_width);
4254 0 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4255 0 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4256 0 : READ_BOOL_FIELD(scan.plan.async_capable);
4257 0 : READ_INT_FIELD(scan.plan.plan_node_id);
4258 0 : READ_NODE_FIELD(scan.plan.targetlist);
4259 0 : READ_NODE_FIELD(scan.plan.qual);
4260 0 : READ_NODE_FIELD(scan.plan.lefttree);
4261 0 : READ_NODE_FIELD(scan.plan.righttree);
4262 0 : READ_NODE_FIELD(scan.plan.initPlan);
4263 0 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4264 0 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4265 0 : READ_UINT_FIELD(scan.scanrelid);
4266 0 : READ_NODE_FIELD(tidrangequals);
4267 :
4268 0 : READ_DONE();
4269 : }
4270 :
4271 : static SubqueryScan *
4272 0 : _readSubqueryScan(void)
4273 : {
4274 0 : READ_LOCALS(SubqueryScan);
4275 :
4276 0 : READ_INT_FIELD(scan.plan.disabled_nodes);
4277 0 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4278 0 : READ_FLOAT_FIELD(scan.plan.total_cost);
4279 0 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4280 0 : READ_INT_FIELD(scan.plan.plan_width);
4281 0 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4282 0 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4283 0 : READ_BOOL_FIELD(scan.plan.async_capable);
4284 0 : READ_INT_FIELD(scan.plan.plan_node_id);
4285 0 : READ_NODE_FIELD(scan.plan.targetlist);
4286 0 : READ_NODE_FIELD(scan.plan.qual);
4287 0 : READ_NODE_FIELD(scan.plan.lefttree);
4288 0 : READ_NODE_FIELD(scan.plan.righttree);
4289 0 : READ_NODE_FIELD(scan.plan.initPlan);
4290 0 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4291 0 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4292 0 : READ_UINT_FIELD(scan.scanrelid);
4293 0 : READ_NODE_FIELD(subplan);
4294 0 : READ_ENUM_FIELD(scanstatus, SubqueryScanStatus);
4295 :
4296 0 : READ_DONE();
4297 : }
4298 :
4299 : static FunctionScan *
4300 24 : _readFunctionScan(void)
4301 : {
4302 24 : READ_LOCALS(FunctionScan);
4303 :
4304 24 : READ_INT_FIELD(scan.plan.disabled_nodes);
4305 24 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4306 24 : READ_FLOAT_FIELD(scan.plan.total_cost);
4307 24 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4308 24 : READ_INT_FIELD(scan.plan.plan_width);
4309 24 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4310 24 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4311 24 : READ_BOOL_FIELD(scan.plan.async_capable);
4312 24 : READ_INT_FIELD(scan.plan.plan_node_id);
4313 24 : READ_NODE_FIELD(scan.plan.targetlist);
4314 24 : READ_NODE_FIELD(scan.plan.qual);
4315 24 : READ_NODE_FIELD(scan.plan.lefttree);
4316 24 : READ_NODE_FIELD(scan.plan.righttree);
4317 24 : READ_NODE_FIELD(scan.plan.initPlan);
4318 24 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4319 24 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4320 24 : READ_UINT_FIELD(scan.scanrelid);
4321 24 : READ_NODE_FIELD(functions);
4322 24 : READ_BOOL_FIELD(funcordinality);
4323 :
4324 24 : READ_DONE();
4325 : }
4326 :
4327 : static ValuesScan *
4328 0 : _readValuesScan(void)
4329 : {
4330 0 : READ_LOCALS(ValuesScan);
4331 :
4332 0 : READ_INT_FIELD(scan.plan.disabled_nodes);
4333 0 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4334 0 : READ_FLOAT_FIELD(scan.plan.total_cost);
4335 0 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4336 0 : READ_INT_FIELD(scan.plan.plan_width);
4337 0 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4338 0 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4339 0 : READ_BOOL_FIELD(scan.plan.async_capable);
4340 0 : READ_INT_FIELD(scan.plan.plan_node_id);
4341 0 : READ_NODE_FIELD(scan.plan.targetlist);
4342 0 : READ_NODE_FIELD(scan.plan.qual);
4343 0 : READ_NODE_FIELD(scan.plan.lefttree);
4344 0 : READ_NODE_FIELD(scan.plan.righttree);
4345 0 : READ_NODE_FIELD(scan.plan.initPlan);
4346 0 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4347 0 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4348 0 : READ_UINT_FIELD(scan.scanrelid);
4349 0 : READ_NODE_FIELD(values_lists);
4350 :
4351 0 : READ_DONE();
4352 : }
4353 :
4354 : static TableFuncScan *
4355 0 : _readTableFuncScan(void)
4356 : {
4357 0 : READ_LOCALS(TableFuncScan);
4358 :
4359 0 : READ_INT_FIELD(scan.plan.disabled_nodes);
4360 0 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4361 0 : READ_FLOAT_FIELD(scan.plan.total_cost);
4362 0 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4363 0 : READ_INT_FIELD(scan.plan.plan_width);
4364 0 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4365 0 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4366 0 : READ_BOOL_FIELD(scan.plan.async_capable);
4367 0 : READ_INT_FIELD(scan.plan.plan_node_id);
4368 0 : READ_NODE_FIELD(scan.plan.targetlist);
4369 0 : READ_NODE_FIELD(scan.plan.qual);
4370 0 : READ_NODE_FIELD(scan.plan.lefttree);
4371 0 : READ_NODE_FIELD(scan.plan.righttree);
4372 0 : READ_NODE_FIELD(scan.plan.initPlan);
4373 0 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4374 0 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4375 0 : READ_UINT_FIELD(scan.scanrelid);
4376 0 : READ_NODE_FIELD(tablefunc);
4377 :
4378 0 : READ_DONE();
4379 : }
4380 :
4381 : static CteScan *
4382 0 : _readCteScan(void)
4383 : {
4384 0 : READ_LOCALS(CteScan);
4385 :
4386 0 : READ_INT_FIELD(scan.plan.disabled_nodes);
4387 0 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4388 0 : READ_FLOAT_FIELD(scan.plan.total_cost);
4389 0 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4390 0 : READ_INT_FIELD(scan.plan.plan_width);
4391 0 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4392 0 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4393 0 : READ_BOOL_FIELD(scan.plan.async_capable);
4394 0 : READ_INT_FIELD(scan.plan.plan_node_id);
4395 0 : READ_NODE_FIELD(scan.plan.targetlist);
4396 0 : READ_NODE_FIELD(scan.plan.qual);
4397 0 : READ_NODE_FIELD(scan.plan.lefttree);
4398 0 : READ_NODE_FIELD(scan.plan.righttree);
4399 0 : READ_NODE_FIELD(scan.plan.initPlan);
4400 0 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4401 0 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4402 0 : READ_UINT_FIELD(scan.scanrelid);
4403 0 : READ_INT_FIELD(ctePlanId);
4404 0 : READ_INT_FIELD(cteParam);
4405 :
4406 0 : READ_DONE();
4407 : }
4408 :
4409 : static NamedTuplestoreScan *
4410 0 : _readNamedTuplestoreScan(void)
4411 : {
4412 0 : READ_LOCALS(NamedTuplestoreScan);
4413 :
4414 0 : READ_INT_FIELD(scan.plan.disabled_nodes);
4415 0 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4416 0 : READ_FLOAT_FIELD(scan.plan.total_cost);
4417 0 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4418 0 : READ_INT_FIELD(scan.plan.plan_width);
4419 0 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4420 0 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4421 0 : READ_BOOL_FIELD(scan.plan.async_capable);
4422 0 : READ_INT_FIELD(scan.plan.plan_node_id);
4423 0 : READ_NODE_FIELD(scan.plan.targetlist);
4424 0 : READ_NODE_FIELD(scan.plan.qual);
4425 0 : READ_NODE_FIELD(scan.plan.lefttree);
4426 0 : READ_NODE_FIELD(scan.plan.righttree);
4427 0 : READ_NODE_FIELD(scan.plan.initPlan);
4428 0 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4429 0 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4430 0 : READ_UINT_FIELD(scan.scanrelid);
4431 0 : READ_STRING_FIELD(enrname);
4432 :
4433 0 : READ_DONE();
4434 : }
4435 :
4436 : static WorkTableScan *
4437 0 : _readWorkTableScan(void)
4438 : {
4439 0 : READ_LOCALS(WorkTableScan);
4440 :
4441 0 : READ_INT_FIELD(scan.plan.disabled_nodes);
4442 0 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4443 0 : READ_FLOAT_FIELD(scan.plan.total_cost);
4444 0 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4445 0 : READ_INT_FIELD(scan.plan.plan_width);
4446 0 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4447 0 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4448 0 : READ_BOOL_FIELD(scan.plan.async_capable);
4449 0 : READ_INT_FIELD(scan.plan.plan_node_id);
4450 0 : READ_NODE_FIELD(scan.plan.targetlist);
4451 0 : READ_NODE_FIELD(scan.plan.qual);
4452 0 : READ_NODE_FIELD(scan.plan.lefttree);
4453 0 : READ_NODE_FIELD(scan.plan.righttree);
4454 0 : READ_NODE_FIELD(scan.plan.initPlan);
4455 0 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4456 0 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4457 0 : READ_UINT_FIELD(scan.scanrelid);
4458 0 : READ_INT_FIELD(wtParam);
4459 :
4460 0 : READ_DONE();
4461 : }
4462 :
4463 : static ForeignScan *
4464 0 : _readForeignScan(void)
4465 : {
4466 0 : READ_LOCALS(ForeignScan);
4467 :
4468 0 : READ_INT_FIELD(scan.plan.disabled_nodes);
4469 0 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4470 0 : READ_FLOAT_FIELD(scan.plan.total_cost);
4471 0 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4472 0 : READ_INT_FIELD(scan.plan.plan_width);
4473 0 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4474 0 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4475 0 : READ_BOOL_FIELD(scan.plan.async_capable);
4476 0 : READ_INT_FIELD(scan.plan.plan_node_id);
4477 0 : READ_NODE_FIELD(scan.plan.targetlist);
4478 0 : READ_NODE_FIELD(scan.plan.qual);
4479 0 : READ_NODE_FIELD(scan.plan.lefttree);
4480 0 : READ_NODE_FIELD(scan.plan.righttree);
4481 0 : READ_NODE_FIELD(scan.plan.initPlan);
4482 0 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4483 0 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4484 0 : READ_UINT_FIELD(scan.scanrelid);
4485 0 : READ_ENUM_FIELD(operation, CmdType);
4486 0 : READ_UINT_FIELD(resultRelation);
4487 0 : READ_OID_FIELD(checkAsUser);
4488 0 : READ_OID_FIELD(fs_server);
4489 0 : READ_NODE_FIELD(fdw_exprs);
4490 0 : READ_NODE_FIELD(fdw_private);
4491 0 : READ_NODE_FIELD(fdw_scan_tlist);
4492 0 : READ_NODE_FIELD(fdw_recheck_quals);
4493 0 : READ_BITMAPSET_FIELD(fs_relids);
4494 0 : READ_BITMAPSET_FIELD(fs_base_relids);
4495 0 : READ_BOOL_FIELD(fsSystemCol);
4496 :
4497 0 : READ_DONE();
4498 : }
4499 :
4500 : static CustomScan *
4501 0 : _readCustomScan(void)
4502 : {
4503 0 : READ_LOCALS(CustomScan);
4504 :
4505 0 : READ_INT_FIELD(scan.plan.disabled_nodes);
4506 0 : READ_FLOAT_FIELD(scan.plan.startup_cost);
4507 0 : READ_FLOAT_FIELD(scan.plan.total_cost);
4508 0 : READ_FLOAT_FIELD(scan.plan.plan_rows);
4509 0 : READ_INT_FIELD(scan.plan.plan_width);
4510 0 : READ_BOOL_FIELD(scan.plan.parallel_aware);
4511 0 : READ_BOOL_FIELD(scan.plan.parallel_safe);
4512 0 : READ_BOOL_FIELD(scan.plan.async_capable);
4513 0 : READ_INT_FIELD(scan.plan.plan_node_id);
4514 0 : READ_NODE_FIELD(scan.plan.targetlist);
4515 0 : READ_NODE_FIELD(scan.plan.qual);
4516 0 : READ_NODE_FIELD(scan.plan.lefttree);
4517 0 : READ_NODE_FIELD(scan.plan.righttree);
4518 0 : READ_NODE_FIELD(scan.plan.initPlan);
4519 0 : READ_BITMAPSET_FIELD(scan.plan.extParam);
4520 0 : READ_BITMAPSET_FIELD(scan.plan.allParam);
4521 0 : READ_UINT_FIELD(scan.scanrelid);
4522 0 : READ_UINT_FIELD(flags);
4523 0 : READ_NODE_FIELD(custom_plans);
4524 0 : READ_NODE_FIELD(custom_exprs);
4525 0 : READ_NODE_FIELD(custom_private);
4526 0 : READ_NODE_FIELD(custom_scan_tlist);
4527 0 : READ_BITMAPSET_FIELD(custom_relids);
4528 :
4529 : {
4530 : /* Lookup CustomScanMethods by CustomName */
4531 : char *custom_name;
4532 : const CustomScanMethods *methods;
4533 0 : token = pg_strtok(&length); /* skip methods: */
4534 0 : token = pg_strtok(&length); /* CustomName */
4535 0 : custom_name = nullable_string(token, length);
4536 0 : methods = GetCustomScanMethods(custom_name, false);
4537 0 : local_node->methods = methods;
4538 : }
4539 :
4540 0 : READ_DONE();
4541 : }
4542 :
4543 : static NestLoop *
4544 42 : _readNestLoop(void)
4545 : {
4546 42 : READ_LOCALS(NestLoop);
4547 :
4548 42 : READ_INT_FIELD(join.plan.disabled_nodes);
4549 42 : READ_FLOAT_FIELD(join.plan.startup_cost);
4550 42 : READ_FLOAT_FIELD(join.plan.total_cost);
4551 42 : READ_FLOAT_FIELD(join.plan.plan_rows);
4552 42 : READ_INT_FIELD(join.plan.plan_width);
4553 42 : READ_BOOL_FIELD(join.plan.parallel_aware);
4554 42 : READ_BOOL_FIELD(join.plan.parallel_safe);
4555 42 : READ_BOOL_FIELD(join.plan.async_capable);
4556 42 : READ_INT_FIELD(join.plan.plan_node_id);
4557 42 : READ_NODE_FIELD(join.plan.targetlist);
4558 42 : READ_NODE_FIELD(join.plan.qual);
4559 42 : READ_NODE_FIELD(join.plan.lefttree);
4560 42 : READ_NODE_FIELD(join.plan.righttree);
4561 42 : READ_NODE_FIELD(join.plan.initPlan);
4562 42 : READ_BITMAPSET_FIELD(join.plan.extParam);
4563 42 : READ_BITMAPSET_FIELD(join.plan.allParam);
4564 42 : READ_ENUM_FIELD(join.jointype, JoinType);
4565 42 : READ_BOOL_FIELD(join.inner_unique);
4566 42 : READ_NODE_FIELD(join.joinqual);
4567 42 : READ_NODE_FIELD(nestParams);
4568 :
4569 42 : READ_DONE();
4570 : }
4571 :
4572 : static NestLoopParam *
4573 42 : _readNestLoopParam(void)
4574 : {
4575 42 : READ_LOCALS(NestLoopParam);
4576 :
4577 42 : READ_INT_FIELD(paramno);
4578 42 : READ_NODE_FIELD(paramval);
4579 :
4580 42 : READ_DONE();
4581 : }
4582 :
4583 : static MergeJoin *
4584 24 : _readMergeJoin(void)
4585 : {
4586 24 : READ_LOCALS(MergeJoin);
4587 :
4588 24 : READ_INT_FIELD(join.plan.disabled_nodes);
4589 24 : READ_FLOAT_FIELD(join.plan.startup_cost);
4590 24 : READ_FLOAT_FIELD(join.plan.total_cost);
4591 24 : READ_FLOAT_FIELD(join.plan.plan_rows);
4592 24 : READ_INT_FIELD(join.plan.plan_width);
4593 24 : READ_BOOL_FIELD(join.plan.parallel_aware);
4594 24 : READ_BOOL_FIELD(join.plan.parallel_safe);
4595 24 : READ_BOOL_FIELD(join.plan.async_capable);
4596 24 : READ_INT_FIELD(join.plan.plan_node_id);
4597 24 : READ_NODE_FIELD(join.plan.targetlist);
4598 24 : READ_NODE_FIELD(join.plan.qual);
4599 24 : READ_NODE_FIELD(join.plan.lefttree);
4600 24 : READ_NODE_FIELD(join.plan.righttree);
4601 24 : READ_NODE_FIELD(join.plan.initPlan);
4602 24 : READ_BITMAPSET_FIELD(join.plan.extParam);
4603 24 : READ_BITMAPSET_FIELD(join.plan.allParam);
4604 24 : READ_ENUM_FIELD(join.jointype, JoinType);
4605 24 : READ_BOOL_FIELD(join.inner_unique);
4606 24 : READ_NODE_FIELD(join.joinqual);
4607 24 : READ_BOOL_FIELD(skip_mark_restore);
4608 24 : READ_NODE_FIELD(mergeclauses);
4609 24 : READ_OID_ARRAY(mergeFamilies, list_length(local_node->mergeclauses));
4610 24 : READ_OID_ARRAY(mergeCollations, list_length(local_node->mergeclauses));
4611 24 : READ_BOOL_ARRAY(mergeReversals, list_length(local_node->mergeclauses));
4612 24 : READ_BOOL_ARRAY(mergeNullsFirst, list_length(local_node->mergeclauses));
4613 :
4614 24 : READ_DONE();
4615 : }
4616 :
4617 : static HashJoin *
4618 558 : _readHashJoin(void)
4619 : {
4620 558 : READ_LOCALS(HashJoin);
4621 :
4622 558 : READ_INT_FIELD(join.plan.disabled_nodes);
4623 558 : READ_FLOAT_FIELD(join.plan.startup_cost);
4624 558 : READ_FLOAT_FIELD(join.plan.total_cost);
4625 558 : READ_FLOAT_FIELD(join.plan.plan_rows);
4626 558 : READ_INT_FIELD(join.plan.plan_width);
4627 558 : READ_BOOL_FIELD(join.plan.parallel_aware);
4628 558 : READ_BOOL_FIELD(join.plan.parallel_safe);
4629 558 : READ_BOOL_FIELD(join.plan.async_capable);
4630 558 : READ_INT_FIELD(join.plan.plan_node_id);
4631 558 : READ_NODE_FIELD(join.plan.targetlist);
4632 558 : READ_NODE_FIELD(join.plan.qual);
4633 558 : READ_NODE_FIELD(join.plan.lefttree);
4634 558 : READ_NODE_FIELD(join.plan.righttree);
4635 558 : READ_NODE_FIELD(join.plan.initPlan);
4636 558 : READ_BITMAPSET_FIELD(join.plan.extParam);
4637 558 : READ_BITMAPSET_FIELD(join.plan.allParam);
4638 558 : READ_ENUM_FIELD(join.jointype, JoinType);
4639 558 : READ_BOOL_FIELD(join.inner_unique);
4640 558 : READ_NODE_FIELD(join.joinqual);
4641 558 : READ_NODE_FIELD(hashclauses);
4642 558 : READ_NODE_FIELD(hashoperators);
4643 558 : READ_NODE_FIELD(hashcollations);
4644 558 : READ_NODE_FIELD(hashkeys);
4645 :
4646 558 : READ_DONE();
4647 : }
4648 :
4649 : static Material *
4650 0 : _readMaterial(void)
4651 : {
4652 0 : READ_LOCALS(Material);
4653 :
4654 0 : READ_INT_FIELD(plan.disabled_nodes);
4655 0 : READ_FLOAT_FIELD(plan.startup_cost);
4656 0 : READ_FLOAT_FIELD(plan.total_cost);
4657 0 : READ_FLOAT_FIELD(plan.plan_rows);
4658 0 : READ_INT_FIELD(plan.plan_width);
4659 0 : READ_BOOL_FIELD(plan.parallel_aware);
4660 0 : READ_BOOL_FIELD(plan.parallel_safe);
4661 0 : READ_BOOL_FIELD(plan.async_capable);
4662 0 : READ_INT_FIELD(plan.plan_node_id);
4663 0 : READ_NODE_FIELD(plan.targetlist);
4664 0 : READ_NODE_FIELD(plan.qual);
4665 0 : READ_NODE_FIELD(plan.lefttree);
4666 0 : READ_NODE_FIELD(plan.righttree);
4667 0 : READ_NODE_FIELD(plan.initPlan);
4668 0 : READ_BITMAPSET_FIELD(plan.extParam);
4669 0 : READ_BITMAPSET_FIELD(plan.allParam);
4670 :
4671 0 : READ_DONE();
4672 : }
4673 :
4674 : static Memoize *
4675 12 : _readMemoize(void)
4676 : {
4677 12 : READ_LOCALS(Memoize);
4678 :
4679 12 : READ_INT_FIELD(plan.disabled_nodes);
4680 12 : READ_FLOAT_FIELD(plan.startup_cost);
4681 12 : READ_FLOAT_FIELD(plan.total_cost);
4682 12 : READ_FLOAT_FIELD(plan.plan_rows);
4683 12 : READ_INT_FIELD(plan.plan_width);
4684 12 : READ_BOOL_FIELD(plan.parallel_aware);
4685 12 : READ_BOOL_FIELD(plan.parallel_safe);
4686 12 : READ_BOOL_FIELD(plan.async_capable);
4687 12 : READ_INT_FIELD(plan.plan_node_id);
4688 12 : READ_NODE_FIELD(plan.targetlist);
4689 12 : READ_NODE_FIELD(plan.qual);
4690 12 : READ_NODE_FIELD(plan.lefttree);
4691 12 : READ_NODE_FIELD(plan.righttree);
4692 12 : READ_NODE_FIELD(plan.initPlan);
4693 12 : READ_BITMAPSET_FIELD(plan.extParam);
4694 12 : READ_BITMAPSET_FIELD(plan.allParam);
4695 12 : READ_INT_FIELD(numKeys);
4696 12 : READ_OID_ARRAY(hashOperators, local_node->numKeys);
4697 12 : READ_OID_ARRAY(collations, local_node->numKeys);
4698 12 : READ_NODE_FIELD(param_exprs);
4699 12 : READ_BOOL_FIELD(singlerow);
4700 12 : READ_BOOL_FIELD(binary_mode);
4701 12 : READ_UINT_FIELD(est_entries);
4702 12 : READ_BITMAPSET_FIELD(keyparamids);
4703 12 : READ_FLOAT_FIELD(est_calls);
4704 12 : READ_FLOAT_FIELD(est_unique_keys);
4705 12 : READ_FLOAT_FIELD(est_hit_ratio);
4706 :
4707 12 : READ_DONE();
4708 : }
4709 :
4710 : static Sort *
4711 460 : _readSort(void)
4712 : {
4713 460 : READ_LOCALS(Sort);
4714 :
4715 460 : READ_INT_FIELD(plan.disabled_nodes);
4716 460 : READ_FLOAT_FIELD(plan.startup_cost);
4717 460 : READ_FLOAT_FIELD(plan.total_cost);
4718 460 : READ_FLOAT_FIELD(plan.plan_rows);
4719 460 : READ_INT_FIELD(plan.plan_width);
4720 460 : READ_BOOL_FIELD(plan.parallel_aware);
4721 460 : READ_BOOL_FIELD(plan.parallel_safe);
4722 460 : READ_BOOL_FIELD(plan.async_capable);
4723 460 : READ_INT_FIELD(plan.plan_node_id);
4724 460 : READ_NODE_FIELD(plan.targetlist);
4725 460 : READ_NODE_FIELD(plan.qual);
4726 460 : READ_NODE_FIELD(plan.lefttree);
4727 460 : READ_NODE_FIELD(plan.righttree);
4728 460 : READ_NODE_FIELD(plan.initPlan);
4729 460 : READ_BITMAPSET_FIELD(plan.extParam);
4730 460 : READ_BITMAPSET_FIELD(plan.allParam);
4731 460 : READ_INT_FIELD(numCols);
4732 460 : READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
4733 460 : READ_OID_ARRAY(sortOperators, local_node->numCols);
4734 460 : READ_OID_ARRAY(collations, local_node->numCols);
4735 460 : READ_BOOL_ARRAY(nullsFirst, local_node->numCols);
4736 :
4737 460 : READ_DONE();
4738 : }
4739 :
4740 : static IncrementalSort *
4741 0 : _readIncrementalSort(void)
4742 : {
4743 0 : READ_LOCALS(IncrementalSort);
4744 :
4745 0 : READ_INT_FIELD(sort.plan.disabled_nodes);
4746 0 : READ_FLOAT_FIELD(sort.plan.startup_cost);
4747 0 : READ_FLOAT_FIELD(sort.plan.total_cost);
4748 0 : READ_FLOAT_FIELD(sort.plan.plan_rows);
4749 0 : READ_INT_FIELD(sort.plan.plan_width);
4750 0 : READ_BOOL_FIELD(sort.plan.parallel_aware);
4751 0 : READ_BOOL_FIELD(sort.plan.parallel_safe);
4752 0 : READ_BOOL_FIELD(sort.plan.async_capable);
4753 0 : READ_INT_FIELD(sort.plan.plan_node_id);
4754 0 : READ_NODE_FIELD(sort.plan.targetlist);
4755 0 : READ_NODE_FIELD(sort.plan.qual);
4756 0 : READ_NODE_FIELD(sort.plan.lefttree);
4757 0 : READ_NODE_FIELD(sort.plan.righttree);
4758 0 : READ_NODE_FIELD(sort.plan.initPlan);
4759 0 : READ_BITMAPSET_FIELD(sort.plan.extParam);
4760 0 : READ_BITMAPSET_FIELD(sort.plan.allParam);
4761 0 : READ_INT_FIELD(sort.numCols);
4762 0 : READ_ATTRNUMBER_ARRAY(sort.sortColIdx, local_node->sort.numCols);
4763 0 : READ_OID_ARRAY(sort.sortOperators, local_node->sort.numCols);
4764 0 : READ_OID_ARRAY(sort.collations, local_node->sort.numCols);
4765 0 : READ_BOOL_ARRAY(sort.nullsFirst, local_node->sort.numCols);
4766 0 : READ_INT_FIELD(nPresortedCols);
4767 :
4768 0 : READ_DONE();
4769 : }
4770 :
4771 : static Group *
4772 0 : _readGroup(void)
4773 : {
4774 0 : READ_LOCALS(Group);
4775 :
4776 0 : READ_INT_FIELD(plan.disabled_nodes);
4777 0 : READ_FLOAT_FIELD(plan.startup_cost);
4778 0 : READ_FLOAT_FIELD(plan.total_cost);
4779 0 : READ_FLOAT_FIELD(plan.plan_rows);
4780 0 : READ_INT_FIELD(plan.plan_width);
4781 0 : READ_BOOL_FIELD(plan.parallel_aware);
4782 0 : READ_BOOL_FIELD(plan.parallel_safe);
4783 0 : READ_BOOL_FIELD(plan.async_capable);
4784 0 : READ_INT_FIELD(plan.plan_node_id);
4785 0 : READ_NODE_FIELD(plan.targetlist);
4786 0 : READ_NODE_FIELD(plan.qual);
4787 0 : READ_NODE_FIELD(plan.lefttree);
4788 0 : READ_NODE_FIELD(plan.righttree);
4789 0 : READ_NODE_FIELD(plan.initPlan);
4790 0 : READ_BITMAPSET_FIELD(plan.extParam);
4791 0 : READ_BITMAPSET_FIELD(plan.allParam);
4792 0 : READ_INT_FIELD(numCols);
4793 0 : READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols);
4794 0 : READ_OID_ARRAY(grpOperators, local_node->numCols);
4795 0 : READ_OID_ARRAY(grpCollations, local_node->numCols);
4796 :
4797 0 : READ_DONE();
4798 : }
4799 :
4800 : static Agg *
4801 1576 : _readAgg(void)
4802 : {
4803 1576 : READ_LOCALS(Agg);
4804 :
4805 1576 : READ_INT_FIELD(plan.disabled_nodes);
4806 1576 : READ_FLOAT_FIELD(plan.startup_cost);
4807 1576 : READ_FLOAT_FIELD(plan.total_cost);
4808 1576 : READ_FLOAT_FIELD(plan.plan_rows);
4809 1576 : READ_INT_FIELD(plan.plan_width);
4810 1576 : READ_BOOL_FIELD(plan.parallel_aware);
4811 1576 : READ_BOOL_FIELD(plan.parallel_safe);
4812 1576 : READ_BOOL_FIELD(plan.async_capable);
4813 1576 : READ_INT_FIELD(plan.plan_node_id);
4814 1576 : READ_NODE_FIELD(plan.targetlist);
4815 1576 : READ_NODE_FIELD(plan.qual);
4816 1576 : READ_NODE_FIELD(plan.lefttree);
4817 1576 : READ_NODE_FIELD(plan.righttree);
4818 1576 : READ_NODE_FIELD(plan.initPlan);
4819 1576 : READ_BITMAPSET_FIELD(plan.extParam);
4820 1576 : READ_BITMAPSET_FIELD(plan.allParam);
4821 1576 : READ_ENUM_FIELD(aggstrategy, AggStrategy);
4822 1576 : READ_ENUM_FIELD(aggsplit, AggSplit);
4823 1576 : READ_INT_FIELD(numCols);
4824 1576 : READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols);
4825 1576 : READ_OID_ARRAY(grpOperators, local_node->numCols);
4826 1576 : READ_OID_ARRAY(grpCollations, local_node->numCols);
4827 1576 : READ_LONG_FIELD(numGroups);
4828 1576 : READ_UINT64_FIELD(transitionSpace);
4829 1576 : READ_BITMAPSET_FIELD(aggParams);
4830 1576 : READ_NODE_FIELD(groupingSets);
4831 1576 : READ_NODE_FIELD(chain);
4832 :
4833 1576 : READ_DONE();
4834 : }
4835 :
4836 : static WindowAgg *
4837 0 : _readWindowAgg(void)
4838 : {
4839 0 : READ_LOCALS(WindowAgg);
4840 :
4841 0 : READ_INT_FIELD(plan.disabled_nodes);
4842 0 : READ_FLOAT_FIELD(plan.startup_cost);
4843 0 : READ_FLOAT_FIELD(plan.total_cost);
4844 0 : READ_FLOAT_FIELD(plan.plan_rows);
4845 0 : READ_INT_FIELD(plan.plan_width);
4846 0 : READ_BOOL_FIELD(plan.parallel_aware);
4847 0 : READ_BOOL_FIELD(plan.parallel_safe);
4848 0 : READ_BOOL_FIELD(plan.async_capable);
4849 0 : READ_INT_FIELD(plan.plan_node_id);
4850 0 : READ_NODE_FIELD(plan.targetlist);
4851 0 : READ_NODE_FIELD(plan.qual);
4852 0 : READ_NODE_FIELD(plan.lefttree);
4853 0 : READ_NODE_FIELD(plan.righttree);
4854 0 : READ_NODE_FIELD(plan.initPlan);
4855 0 : READ_BITMAPSET_FIELD(plan.extParam);
4856 0 : READ_BITMAPSET_FIELD(plan.allParam);
4857 0 : READ_STRING_FIELD(winname);
4858 0 : READ_UINT_FIELD(winref);
4859 0 : READ_INT_FIELD(partNumCols);
4860 0 : READ_ATTRNUMBER_ARRAY(partColIdx, local_node->partNumCols);
4861 0 : READ_OID_ARRAY(partOperators, local_node->partNumCols);
4862 0 : READ_OID_ARRAY(partCollations, local_node->partNumCols);
4863 0 : READ_INT_FIELD(ordNumCols);
4864 0 : READ_ATTRNUMBER_ARRAY(ordColIdx, local_node->ordNumCols);
4865 0 : READ_OID_ARRAY(ordOperators, local_node->ordNumCols);
4866 0 : READ_OID_ARRAY(ordCollations, local_node->ordNumCols);
4867 0 : READ_INT_FIELD(frameOptions);
4868 0 : READ_NODE_FIELD(startOffset);
4869 0 : READ_NODE_FIELD(endOffset);
4870 0 : READ_NODE_FIELD(runCondition);
4871 0 : READ_NODE_FIELD(runConditionOrig);
4872 0 : READ_OID_FIELD(startInRangeFunc);
4873 0 : READ_OID_FIELD(endInRangeFunc);
4874 0 : READ_OID_FIELD(inRangeColl);
4875 0 : READ_BOOL_FIELD(inRangeAsc);
4876 0 : READ_BOOL_FIELD(inRangeNullsFirst);
4877 0 : READ_BOOL_FIELD(topWindow);
4878 :
4879 0 : READ_DONE();
4880 : }
4881 :
4882 : static Unique *
4883 6 : _readUnique(void)
4884 : {
4885 6 : READ_LOCALS(Unique);
4886 :
4887 6 : READ_INT_FIELD(plan.disabled_nodes);
4888 6 : READ_FLOAT_FIELD(plan.startup_cost);
4889 6 : READ_FLOAT_FIELD(plan.total_cost);
4890 6 : READ_FLOAT_FIELD(plan.plan_rows);
4891 6 : READ_INT_FIELD(plan.plan_width);
4892 6 : READ_BOOL_FIELD(plan.parallel_aware);
4893 6 : READ_BOOL_FIELD(plan.parallel_safe);
4894 6 : READ_BOOL_FIELD(plan.async_capable);
4895 6 : READ_INT_FIELD(plan.plan_node_id);
4896 6 : READ_NODE_FIELD(plan.targetlist);
4897 6 : READ_NODE_FIELD(plan.qual);
4898 6 : READ_NODE_FIELD(plan.lefttree);
4899 6 : READ_NODE_FIELD(plan.righttree);
4900 6 : READ_NODE_FIELD(plan.initPlan);
4901 6 : READ_BITMAPSET_FIELD(plan.extParam);
4902 6 : READ_BITMAPSET_FIELD(plan.allParam);
4903 6 : READ_INT_FIELD(numCols);
4904 6 : READ_ATTRNUMBER_ARRAY(uniqColIdx, local_node->numCols);
4905 6 : READ_OID_ARRAY(uniqOperators, local_node->numCols);
4906 6 : READ_OID_ARRAY(uniqCollations, local_node->numCols);
4907 :
4908 6 : READ_DONE();
4909 : }
4910 :
4911 : static Gather *
4912 0 : _readGather(void)
4913 : {
4914 0 : READ_LOCALS(Gather);
4915 :
4916 0 : READ_INT_FIELD(plan.disabled_nodes);
4917 0 : READ_FLOAT_FIELD(plan.startup_cost);
4918 0 : READ_FLOAT_FIELD(plan.total_cost);
4919 0 : READ_FLOAT_FIELD(plan.plan_rows);
4920 0 : READ_INT_FIELD(plan.plan_width);
4921 0 : READ_BOOL_FIELD(plan.parallel_aware);
4922 0 : READ_BOOL_FIELD(plan.parallel_safe);
4923 0 : READ_BOOL_FIELD(plan.async_capable);
4924 0 : READ_INT_FIELD(plan.plan_node_id);
4925 0 : READ_NODE_FIELD(plan.targetlist);
4926 0 : READ_NODE_FIELD(plan.qual);
4927 0 : READ_NODE_FIELD(plan.lefttree);
4928 0 : READ_NODE_FIELD(plan.righttree);
4929 0 : READ_NODE_FIELD(plan.initPlan);
4930 0 : READ_BITMAPSET_FIELD(plan.extParam);
4931 0 : READ_BITMAPSET_FIELD(plan.allParam);
4932 0 : READ_INT_FIELD(num_workers);
4933 0 : READ_INT_FIELD(rescan_param);
4934 0 : READ_BOOL_FIELD(single_copy);
4935 0 : READ_BOOL_FIELD(invisible);
4936 0 : READ_BITMAPSET_FIELD(initParam);
4937 :
4938 0 : READ_DONE();
4939 : }
4940 :
4941 : static GatherMerge *
4942 0 : _readGatherMerge(void)
4943 : {
4944 0 : READ_LOCALS(GatherMerge);
4945 :
4946 0 : READ_INT_FIELD(plan.disabled_nodes);
4947 0 : READ_FLOAT_FIELD(plan.startup_cost);
4948 0 : READ_FLOAT_FIELD(plan.total_cost);
4949 0 : READ_FLOAT_FIELD(plan.plan_rows);
4950 0 : READ_INT_FIELD(plan.plan_width);
4951 0 : READ_BOOL_FIELD(plan.parallel_aware);
4952 0 : READ_BOOL_FIELD(plan.parallel_safe);
4953 0 : READ_BOOL_FIELD(plan.async_capable);
4954 0 : READ_INT_FIELD(plan.plan_node_id);
4955 0 : READ_NODE_FIELD(plan.targetlist);
4956 0 : READ_NODE_FIELD(plan.qual);
4957 0 : READ_NODE_FIELD(plan.lefttree);
4958 0 : READ_NODE_FIELD(plan.righttree);
4959 0 : READ_NODE_FIELD(plan.initPlan);
4960 0 : READ_BITMAPSET_FIELD(plan.extParam);
4961 0 : READ_BITMAPSET_FIELD(plan.allParam);
4962 0 : READ_INT_FIELD(num_workers);
4963 0 : READ_INT_FIELD(rescan_param);
4964 0 : READ_INT_FIELD(numCols);
4965 0 : READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
4966 0 : READ_OID_ARRAY(sortOperators, local_node->numCols);
4967 0 : READ_OID_ARRAY(collations, local_node->numCols);
4968 0 : READ_BOOL_ARRAY(nullsFirst, local_node->numCols);
4969 0 : READ_BITMAPSET_FIELD(initParam);
4970 :
4971 0 : READ_DONE();
4972 : }
4973 :
4974 : static Hash *
4975 558 : _readHash(void)
4976 : {
4977 558 : READ_LOCALS(Hash);
4978 :
4979 558 : READ_INT_FIELD(plan.disabled_nodes);
4980 558 : READ_FLOAT_FIELD(plan.startup_cost);
4981 558 : READ_FLOAT_FIELD(plan.total_cost);
4982 558 : READ_FLOAT_FIELD(plan.plan_rows);
4983 558 : READ_INT_FIELD(plan.plan_width);
4984 558 : READ_BOOL_FIELD(plan.parallel_aware);
4985 558 : READ_BOOL_FIELD(plan.parallel_safe);
4986 558 : READ_BOOL_FIELD(plan.async_capable);
4987 558 : READ_INT_FIELD(plan.plan_node_id);
4988 558 : READ_NODE_FIELD(plan.targetlist);
4989 558 : READ_NODE_FIELD(plan.qual);
4990 558 : READ_NODE_FIELD(plan.lefttree);
4991 558 : READ_NODE_FIELD(plan.righttree);
4992 558 : READ_NODE_FIELD(plan.initPlan);
4993 558 : READ_BITMAPSET_FIELD(plan.extParam);
4994 558 : READ_BITMAPSET_FIELD(plan.allParam);
4995 558 : READ_NODE_FIELD(hashkeys);
4996 558 : READ_OID_FIELD(skewTable);
4997 558 : READ_INT_FIELD(skewColumn);
4998 558 : READ_BOOL_FIELD(skewInherit);
4999 558 : READ_FLOAT_FIELD(rows_total);
5000 :
5001 558 : READ_DONE();
5002 : }
5003 :
5004 : static SetOp *
5005 0 : _readSetOp(void)
5006 : {
5007 0 : READ_LOCALS(SetOp);
5008 :
5009 0 : READ_INT_FIELD(plan.disabled_nodes);
5010 0 : READ_FLOAT_FIELD(plan.startup_cost);
5011 0 : READ_FLOAT_FIELD(plan.total_cost);
5012 0 : READ_FLOAT_FIELD(plan.plan_rows);
5013 0 : READ_INT_FIELD(plan.plan_width);
5014 0 : READ_BOOL_FIELD(plan.parallel_aware);
5015 0 : READ_BOOL_FIELD(plan.parallel_safe);
5016 0 : READ_BOOL_FIELD(plan.async_capable);
5017 0 : READ_INT_FIELD(plan.plan_node_id);
5018 0 : READ_NODE_FIELD(plan.targetlist);
5019 0 : READ_NODE_FIELD(plan.qual);
5020 0 : READ_NODE_FIELD(plan.lefttree);
5021 0 : READ_NODE_FIELD(plan.righttree);
5022 0 : READ_NODE_FIELD(plan.initPlan);
5023 0 : READ_BITMAPSET_FIELD(plan.extParam);
5024 0 : READ_BITMAPSET_FIELD(plan.allParam);
5025 0 : READ_ENUM_FIELD(cmd, SetOpCmd);
5026 0 : READ_ENUM_FIELD(strategy, SetOpStrategy);
5027 0 : READ_INT_FIELD(numCols);
5028 0 : READ_ATTRNUMBER_ARRAY(cmpColIdx, local_node->numCols);
5029 0 : READ_OID_ARRAY(cmpOperators, local_node->numCols);
5030 0 : READ_OID_ARRAY(cmpCollations, local_node->numCols);
5031 0 : READ_BOOL_ARRAY(cmpNullsFirst, local_node->numCols);
5032 0 : READ_LONG_FIELD(numGroups);
5033 :
5034 0 : READ_DONE();
5035 : }
5036 :
5037 : static LockRows *
5038 0 : _readLockRows(void)
5039 : {
5040 0 : READ_LOCALS(LockRows);
5041 :
5042 0 : READ_INT_FIELD(plan.disabled_nodes);
5043 0 : READ_FLOAT_FIELD(plan.startup_cost);
5044 0 : READ_FLOAT_FIELD(plan.total_cost);
5045 0 : READ_FLOAT_FIELD(plan.plan_rows);
5046 0 : READ_INT_FIELD(plan.plan_width);
5047 0 : READ_BOOL_FIELD(plan.parallel_aware);
5048 0 : READ_BOOL_FIELD(plan.parallel_safe);
5049 0 : READ_BOOL_FIELD(plan.async_capable);
5050 0 : READ_INT_FIELD(plan.plan_node_id);
5051 0 : READ_NODE_FIELD(plan.targetlist);
5052 0 : READ_NODE_FIELD(plan.qual);
5053 0 : READ_NODE_FIELD(plan.lefttree);
5054 0 : READ_NODE_FIELD(plan.righttree);
5055 0 : READ_NODE_FIELD(plan.initPlan);
5056 0 : READ_BITMAPSET_FIELD(plan.extParam);
5057 0 : READ_BITMAPSET_FIELD(plan.allParam);
5058 0 : READ_NODE_FIELD(rowMarks);
5059 0 : READ_INT_FIELD(epqParam);
5060 :
5061 0 : READ_DONE();
5062 : }
5063 :
5064 : static Limit *
5065 4 : _readLimit(void)
5066 : {
5067 4 : READ_LOCALS(Limit);
5068 :
5069 4 : READ_INT_FIELD(plan.disabled_nodes);
5070 4 : READ_FLOAT_FIELD(plan.startup_cost);
5071 4 : READ_FLOAT_FIELD(plan.total_cost);
5072 4 : READ_FLOAT_FIELD(plan.plan_rows);
5073 4 : READ_INT_FIELD(plan.plan_width);
5074 4 : READ_BOOL_FIELD(plan.parallel_aware);
5075 4 : READ_BOOL_FIELD(plan.parallel_safe);
5076 4 : READ_BOOL_FIELD(plan.async_capable);
5077 4 : READ_INT_FIELD(plan.plan_node_id);
5078 4 : READ_NODE_FIELD(plan.targetlist);
5079 4 : READ_NODE_FIELD(plan.qual);
5080 4 : READ_NODE_FIELD(plan.lefttree);
5081 4 : READ_NODE_FIELD(plan.righttree);
5082 4 : READ_NODE_FIELD(plan.initPlan);
5083 4 : READ_BITMAPSET_FIELD(plan.extParam);
5084 4 : READ_BITMAPSET_FIELD(plan.allParam);
5085 4 : READ_NODE_FIELD(limitOffset);
5086 4 : READ_NODE_FIELD(limitCount);
5087 4 : READ_ENUM_FIELD(limitOption, LimitOption);
5088 4 : READ_INT_FIELD(uniqNumCols);
5089 4 : READ_ATTRNUMBER_ARRAY(uniqColIdx, local_node->uniqNumCols);
5090 4 : READ_OID_ARRAY(uniqOperators, local_node->uniqNumCols);
5091 4 : READ_OID_ARRAY(uniqCollations, local_node->uniqNumCols);
5092 :
5093 4 : READ_DONE();
5094 : }
5095 :
5096 : static PlanRowMark *
5097 0 : _readPlanRowMark(void)
5098 : {
5099 0 : READ_LOCALS(PlanRowMark);
5100 :
5101 0 : READ_UINT_FIELD(rti);
5102 0 : READ_UINT_FIELD(prti);
5103 0 : READ_UINT_FIELD(rowmarkId);
5104 0 : READ_ENUM_FIELD(markType, RowMarkType);
5105 0 : READ_INT_FIELD(allMarkTypes);
5106 0 : READ_ENUM_FIELD(strength, LockClauseStrength);
5107 0 : READ_ENUM_FIELD(waitPolicy, LockWaitPolicy);
5108 0 : READ_BOOL_FIELD(isParent);
5109 :
5110 0 : READ_DONE();
5111 : }
5112 :
5113 : static PartitionPruneInfo *
5114 126 : _readPartitionPruneInfo(void)
5115 : {
5116 126 : READ_LOCALS(PartitionPruneInfo);
5117 :
5118 126 : READ_BITMAPSET_FIELD(relids);
5119 126 : READ_NODE_FIELD(prune_infos);
5120 126 : READ_BITMAPSET_FIELD(other_subplans);
5121 :
5122 126 : READ_DONE();
5123 : }
5124 :
5125 : static PartitionedRelPruneInfo *
5126 396 : _readPartitionedRelPruneInfo(void)
5127 : {
5128 396 : READ_LOCALS(PartitionedRelPruneInfo);
5129 :
5130 396 : READ_UINT_FIELD(rtindex);
5131 396 : READ_BITMAPSET_FIELD(present_parts);
5132 396 : READ_INT_FIELD(nparts);
5133 396 : READ_INT_ARRAY(subplan_map, local_node->nparts);
5134 396 : READ_INT_ARRAY(subpart_map, local_node->nparts);
5135 396 : READ_INT_ARRAY(leafpart_rti_map, local_node->nparts);
5136 396 : READ_OID_ARRAY(relid_map, local_node->nparts);
5137 396 : READ_NODE_FIELD(initial_pruning_steps);
5138 396 : READ_NODE_FIELD(exec_pruning_steps);
5139 396 : READ_BITMAPSET_FIELD(execparamids);
5140 :
5141 396 : READ_DONE();
5142 : }
5143 :
5144 : static PartitionPruneStepOp *
5145 222 : _readPartitionPruneStepOp(void)
5146 : {
5147 222 : READ_LOCALS(PartitionPruneStepOp);
5148 :
5149 222 : READ_INT_FIELD(step.step_id);
5150 222 : READ_INT_FIELD(opstrategy);
5151 222 : READ_NODE_FIELD(exprs);
5152 222 : READ_NODE_FIELD(cmpfns);
5153 222 : READ_BITMAPSET_FIELD(nullkeys);
5154 :
5155 222 : READ_DONE();
5156 : }
5157 :
5158 : static PartitionPruneStepCombine *
5159 60 : _readPartitionPruneStepCombine(void)
5160 : {
5161 60 : READ_LOCALS(PartitionPruneStepCombine);
5162 :
5163 60 : READ_INT_FIELD(step.step_id);
5164 60 : READ_ENUM_FIELD(combineOp, PartitionPruneCombineOp);
5165 60 : READ_NODE_FIELD(source_stepids);
5166 :
5167 60 : READ_DONE();
5168 : }
5169 :
5170 : static PlanInvalItem *
5171 0 : _readPlanInvalItem(void)
5172 : {
5173 0 : READ_LOCALS(PlanInvalItem);
5174 :
5175 0 : READ_INT_FIELD(cacheId);
5176 0 : READ_UINT_FIELD(hashValue);
5177 :
5178 0 : READ_DONE();
5179 : }
|
