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