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