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