Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * equalfuncs.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 bool
43 1367603 : _equalAlias(const Alias *a, const Alias *b)
44 : {
45 1367603 : COMPARE_STRING_FIELD(aliasname);
46 1367592 : COMPARE_NODE_FIELD(colnames);
47 :
48 1367592 : return true;
49 : }
50 :
51 : static bool
52 898308 : _equalRangeVar(const RangeVar *a, const RangeVar *b)
53 : {
54 898308 : COMPARE_STRING_FIELD(catalogname);
55 898308 : COMPARE_STRING_FIELD(schemaname);
56 898266 : COMPARE_STRING_FIELD(relname);
57 897184 : COMPARE_SCALAR_FIELD(inh);
58 897184 : COMPARE_SCALAR_FIELD(relpersistence);
59 897184 : COMPARE_NODE_FIELD(alias);
60 : COMPARE_LOCATION_FIELD(location);
61 :
62 897184 : return true;
63 : }
64 :
65 : static bool
66 584 : _equalTableFunc(const TableFunc *a, const TableFunc *b)
67 : {
68 584 : COMPARE_SCALAR_FIELD(functype);
69 584 : COMPARE_NODE_FIELD(ns_uris);
70 584 : COMPARE_NODE_FIELD(ns_names);
71 584 : COMPARE_NODE_FIELD(docexpr);
72 584 : COMPARE_NODE_FIELD(rowexpr);
73 584 : COMPARE_NODE_FIELD(colnames);
74 584 : COMPARE_NODE_FIELD(coltypes);
75 584 : COMPARE_NODE_FIELD(coltypmods);
76 584 : COMPARE_NODE_FIELD(colcollations);
77 584 : COMPARE_NODE_FIELD(colexprs);
78 584 : COMPARE_NODE_FIELD(coldefexprs);
79 584 : COMPARE_NODE_FIELD(colvalexprs);
80 584 : COMPARE_NODE_FIELD(passingvalexprs);
81 584 : COMPARE_BITMAPSET_FIELD(notnulls);
82 584 : COMPARE_NODE_FIELD(plan);
83 584 : COMPARE_SCALAR_FIELD(ordinalitycol);
84 : COMPARE_LOCATION_FIELD(location);
85 :
86 584 : return true;
87 : }
88 :
89 : static bool
90 4010 : _equalIntoClause(const IntoClause *a, const IntoClause *b)
91 : {
92 4010 : COMPARE_NODE_FIELD(rel);
93 4010 : COMPARE_NODE_FIELD(colNames);
94 4010 : COMPARE_STRING_FIELD(accessMethod);
95 4010 : COMPARE_NODE_FIELD(options);
96 4010 : COMPARE_SCALAR_FIELD(onCommit);
97 4010 : COMPARE_STRING_FIELD(tableSpaceName);
98 4010 : COMPARE_NODE_FIELD(viewQuery);
99 4010 : COMPARE_SCALAR_FIELD(skipData);
100 :
101 4010 : return true;
102 : }
103 :
104 : static bool
105 9088062 : _equalVar(const Var *a, const Var *b)
106 : {
107 9088062 : COMPARE_SCALAR_FIELD(varno);
108 7554579 : COMPARE_SCALAR_FIELD(varattno);
109 6725638 : COMPARE_SCALAR_FIELD(vartype);
110 6725638 : COMPARE_SCALAR_FIELD(vartypmod);
111 6725638 : COMPARE_SCALAR_FIELD(varcollid);
112 6725638 : COMPARE_BITMAPSET_FIELD(varnullingrels);
113 6716737 : COMPARE_SCALAR_FIELD(varlevelsup);
114 6716734 : COMPARE_SCALAR_FIELD(varreturningtype);
115 : COMPARE_LOCATION_FIELD(location);
116 :
117 6716734 : return true;
118 : }
119 :
120 : static bool
121 85716 : _equalParam(const Param *a, const Param *b)
122 : {
123 85716 : COMPARE_SCALAR_FIELD(paramkind);
124 84550 : COMPARE_SCALAR_FIELD(paramid);
125 78395 : COMPARE_SCALAR_FIELD(paramtype);
126 78395 : COMPARE_SCALAR_FIELD(paramtypmod);
127 78395 : COMPARE_SCALAR_FIELD(paramcollid);
128 : COMPARE_LOCATION_FIELD(location);
129 :
130 78395 : return true;
131 : }
132 :
133 : static bool
134 61899 : _equalAggref(const Aggref *a, const Aggref *b)
135 : {
136 61899 : COMPARE_SCALAR_FIELD(aggfnoid);
137 56366 : COMPARE_SCALAR_FIELD(aggtype);
138 56059 : COMPARE_SCALAR_FIELD(aggcollid);
139 56059 : COMPARE_SCALAR_FIELD(inputcollid);
140 56059 : COMPARE_NODE_FIELD(aggargtypes);
141 56059 : COMPARE_NODE_FIELD(aggdirectargs);
142 56059 : COMPARE_NODE_FIELD(args);
143 54837 : COMPARE_NODE_FIELD(aggorder);
144 54837 : COMPARE_NODE_FIELD(aggdistinct);
145 54837 : COMPARE_NODE_FIELD(aggfilter);
146 54828 : COMPARE_SCALAR_FIELD(aggstar);
147 54828 : COMPARE_SCALAR_FIELD(aggvariadic);
148 54828 : COMPARE_SCALAR_FIELD(aggkind);
149 54828 : COMPARE_SCALAR_FIELD(agglevelsup);
150 54828 : COMPARE_SCALAR_FIELD(aggsplit);
151 54810 : COMPARE_SCALAR_FIELD(aggno);
152 54810 : COMPARE_SCALAR_FIELD(aggtransno);
153 : COMPARE_LOCATION_FIELD(location);
154 :
155 54810 : return true;
156 : }
157 :
158 : static bool
159 794 : _equalGroupingFunc(const GroupingFunc *a, const GroupingFunc *b)
160 : {
161 794 : COMPARE_NODE_FIELD(args);
162 794 : COMPARE_SCALAR_FIELD(agglevelsup);
163 : COMPARE_LOCATION_FIELD(location);
164 :
165 794 : return true;
166 : }
167 :
168 : static bool
169 4807 : _equalWindowFunc(const WindowFunc *a, const WindowFunc *b)
170 : {
171 4807 : COMPARE_SCALAR_FIELD(winfnoid);
172 4105 : COMPARE_SCALAR_FIELD(wintype);
173 4105 : COMPARE_SCALAR_FIELD(wincollid);
174 4105 : COMPARE_SCALAR_FIELD(inputcollid);
175 4105 : COMPARE_NODE_FIELD(args);
176 4045 : COMPARE_NODE_FIELD(aggfilter);
177 4039 : COMPARE_NODE_FIELD(runCondition);
178 4039 : COMPARE_SCALAR_FIELD(winref);
179 3979 : COMPARE_SCALAR_FIELD(winstar);
180 3979 : COMPARE_SCALAR_FIELD(winagg);
181 3979 : COMPARE_SCALAR_FIELD(ignore_nulls);
182 : COMPARE_LOCATION_FIELD(location);
183 :
184 3934 : return true;
185 : }
186 :
187 : static bool
188 102 : _equalWindowFuncRunCondition(const WindowFuncRunCondition *a, const WindowFuncRunCondition *b)
189 : {
190 102 : COMPARE_SCALAR_FIELD(opno);
191 102 : COMPARE_SCALAR_FIELD(inputcollid);
192 102 : COMPARE_SCALAR_FIELD(wfunc_left);
193 102 : COMPARE_NODE_FIELD(arg);
194 :
195 102 : return true;
196 : }
197 :
198 : static bool
199 402 : _equalMergeSupportFunc(const MergeSupportFunc *a, const MergeSupportFunc *b)
200 : {
201 402 : COMPARE_SCALAR_FIELD(msftype);
202 402 : COMPARE_SCALAR_FIELD(msfcollid);
203 : COMPARE_LOCATION_FIELD(location);
204 :
205 402 : return true;
206 : }
207 :
208 : static bool
209 14185 : _equalSubscriptingRef(const SubscriptingRef *a, const SubscriptingRef *b)
210 : {
211 14185 : COMPARE_SCALAR_FIELD(refcontainertype);
212 14185 : COMPARE_SCALAR_FIELD(refelemtype);
213 14185 : COMPARE_SCALAR_FIELD(refrestype);
214 14185 : COMPARE_SCALAR_FIELD(reftypmod);
215 14185 : COMPARE_SCALAR_FIELD(refcollid);
216 14185 : COMPARE_NODE_FIELD(refupperindexpr);
217 14131 : COMPARE_NODE_FIELD(reflowerindexpr);
218 14131 : COMPARE_NODE_FIELD(refexpr);
219 14008 : COMPARE_NODE_FIELD(refassgnexpr);
220 :
221 14008 : return true;
222 : }
223 :
224 : static bool
225 424083 : _equalFuncExpr(const FuncExpr *a, const FuncExpr *b)
226 : {
227 424083 : COMPARE_SCALAR_FIELD(funcid);
228 423000 : COMPARE_SCALAR_FIELD(funcresulttype);
229 422928 : COMPARE_SCALAR_FIELD(funcretset);
230 422928 : COMPARE_SCALAR_FIELD(funcvariadic);
231 422928 : COMPARE_SCALAR_FIELD(funccollid);
232 422928 : COMPARE_SCALAR_FIELD(inputcollid);
233 422928 : COMPARE_NODE_FIELD(args);
234 : COMPARE_LOCATION_FIELD(location);
235 :
236 421605 : return true;
237 : }
238 :
239 : static bool
240 94954 : _equalNamedArgExpr(const NamedArgExpr *a, const NamedArgExpr *b)
241 : {
242 94954 : COMPARE_NODE_FIELD(arg);
243 94954 : COMPARE_STRING_FIELD(name);
244 94954 : COMPARE_SCALAR_FIELD(argnumber);
245 : COMPARE_LOCATION_FIELD(location);
246 :
247 94954 : return true;
248 : }
249 :
250 : static bool
251 761860 : _equalOpExpr(const OpExpr *a, const OpExpr *b)
252 : {
253 761860 : COMPARE_SCALAR_FIELD(opno);
254 701049 : if (a->opfuncid != b->opfuncid && a->opfuncid != 0 && b->opfuncid != 0)
255 0 : return false;
256 701049 : COMPARE_SCALAR_FIELD(opresulttype);
257 701049 : COMPARE_SCALAR_FIELD(opretset);
258 701049 : COMPARE_SCALAR_FIELD(opcollid);
259 701049 : COMPARE_SCALAR_FIELD(inputcollid);
260 701048 : COMPARE_NODE_FIELD(args);
261 : COMPARE_LOCATION_FIELD(location);
262 :
263 632649 : return true;
264 : }
265 :
266 : static bool
267 1240 : _equalDistinctExpr(const DistinctExpr *a, const DistinctExpr *b)
268 : {
269 1240 : COMPARE_SCALAR_FIELD(opno);
270 1240 : if (a->opfuncid != b->opfuncid && a->opfuncid != 0 && b->opfuncid != 0)
271 0 : return false;
272 1240 : COMPARE_SCALAR_FIELD(opresulttype);
273 1240 : COMPARE_SCALAR_FIELD(opretset);
274 1240 : COMPARE_SCALAR_FIELD(opcollid);
275 1240 : COMPARE_SCALAR_FIELD(inputcollid);
276 1240 : COMPARE_NODE_FIELD(args);
277 : COMPARE_LOCATION_FIELD(location);
278 :
279 1240 : return true;
280 : }
281 :
282 : static bool
283 177 : _equalNullIfExpr(const NullIfExpr *a, const NullIfExpr *b)
284 : {
285 177 : COMPARE_SCALAR_FIELD(opno);
286 177 : if (a->opfuncid != b->opfuncid && a->opfuncid != 0 && b->opfuncid != 0)
287 0 : return false;
288 177 : COMPARE_SCALAR_FIELD(opresulttype);
289 177 : COMPARE_SCALAR_FIELD(opretset);
290 177 : COMPARE_SCALAR_FIELD(opcollid);
291 177 : COMPARE_SCALAR_FIELD(inputcollid);
292 177 : COMPARE_NODE_FIELD(args);
293 : COMPARE_LOCATION_FIELD(location);
294 :
295 177 : return true;
296 : }
297 :
298 : static bool
299 34113 : _equalScalarArrayOpExpr(const ScalarArrayOpExpr *a, const ScalarArrayOpExpr *b)
300 : {
301 34113 : COMPARE_SCALAR_FIELD(opno);
302 33762 : if (a->opfuncid != b->opfuncid && a->opfuncid != 0 && b->opfuncid != 0)
303 0 : return false;
304 33762 : if (a->hashfuncid != b->hashfuncid && a->hashfuncid != 0 && b->hashfuncid != 0)
305 0 : return false;
306 33762 : if (a->negfuncid != b->negfuncid && a->negfuncid != 0 && b->negfuncid != 0)
307 0 : return false;
308 33762 : COMPARE_SCALAR_FIELD(useOr);
309 33762 : COMPARE_SCALAR_FIELD(inputcollid);
310 33762 : COMPARE_NODE_FIELD(args);
311 : COMPARE_LOCATION_FIELD(location);
312 :
313 33726 : return true;
314 : }
315 :
316 : static bool
317 328173 : _equalBoolExpr(const BoolExpr *a, const BoolExpr *b)
318 : {
319 328173 : COMPARE_SCALAR_FIELD(boolop);
320 328173 : COMPARE_NODE_FIELD(args);
321 : COMPARE_LOCATION_FIELD(location);
322 :
323 327516 : return true;
324 : }
325 :
326 : static bool
327 98731 : _equalSubLink(const SubLink *a, const SubLink *b)
328 : {
329 98731 : COMPARE_SCALAR_FIELD(subLinkType);
330 98731 : COMPARE_SCALAR_FIELD(subLinkId);
331 98731 : COMPARE_NODE_FIELD(testexpr);
332 98725 : COMPARE_NODE_FIELD(operName);
333 98725 : COMPARE_NODE_FIELD(subselect);
334 : COMPARE_LOCATION_FIELD(location);
335 :
336 98711 : return true;
337 : }
338 :
339 : static bool
340 3274 : _equalSubPlan(const SubPlan *a, const SubPlan *b)
341 : {
342 3274 : COMPARE_SCALAR_FIELD(subLinkType);
343 3274 : COMPARE_NODE_FIELD(testexpr);
344 3274 : COMPARE_NODE_FIELD(paramIds);
345 3274 : COMPARE_SCALAR_FIELD(plan_id);
346 3190 : COMPARE_STRING_FIELD(plan_name);
347 3190 : COMPARE_SCALAR_FIELD(firstColType);
348 3190 : COMPARE_SCALAR_FIELD(firstColTypmod);
349 3190 : COMPARE_SCALAR_FIELD(firstColCollation);
350 3190 : COMPARE_SCALAR_FIELD(isInitPlan);
351 3190 : COMPARE_SCALAR_FIELD(useHashTable);
352 3190 : COMPARE_SCALAR_FIELD(unknownEqFalse);
353 3190 : COMPARE_SCALAR_FIELD(parallel_safe);
354 3190 : COMPARE_NODE_FIELD(setParam);
355 3190 : COMPARE_NODE_FIELD(parParam);
356 3190 : COMPARE_NODE_FIELD(args);
357 3190 : COMPARE_SCALAR_FIELD(startup_cost);
358 3190 : COMPARE_SCALAR_FIELD(per_call_cost);
359 :
360 3190 : return true;
361 : }
362 :
363 : static bool
364 0 : _equalAlternativeSubPlan(const AlternativeSubPlan *a, const AlternativeSubPlan *b)
365 : {
366 0 : COMPARE_NODE_FIELD(subplans);
367 :
368 0 : return true;
369 : }
370 :
371 : static bool
372 7823 : _equalFieldSelect(const FieldSelect *a, const FieldSelect *b)
373 : {
374 7823 : COMPARE_NODE_FIELD(arg);
375 7820 : COMPARE_SCALAR_FIELD(fieldnum);
376 7820 : COMPARE_SCALAR_FIELD(resulttype);
377 7820 : COMPARE_SCALAR_FIELD(resulttypmod);
378 7820 : COMPARE_SCALAR_FIELD(resultcollid);
379 :
380 7820 : return true;
381 : }
382 :
383 : static bool
384 388 : _equalFieldStore(const FieldStore *a, const FieldStore *b)
385 : {
386 388 : COMPARE_NODE_FIELD(arg);
387 388 : COMPARE_NODE_FIELD(newvals);
388 388 : COMPARE_NODE_FIELD(fieldnums);
389 388 : COMPARE_SCALAR_FIELD(resulttype);
390 :
391 388 : return true;
392 : }
393 :
394 : static bool
395 166326 : _equalRelabelType(const RelabelType *a, const RelabelType *b)
396 : {
397 166326 : COMPARE_NODE_FIELD(arg);
398 164018 : COMPARE_SCALAR_FIELD(resulttype);
399 164018 : COMPARE_SCALAR_FIELD(resulttypmod);
400 164018 : COMPARE_SCALAR_FIELD(resultcollid);
401 : COMPARE_LOCATION_FIELD(location);
402 :
403 164018 : return true;
404 : }
405 :
406 : static bool
407 28460 : _equalCoerceViaIO(const CoerceViaIO *a, const CoerceViaIO *b)
408 : {
409 28460 : COMPARE_NODE_FIELD(arg);
410 28153 : COMPARE_SCALAR_FIELD(resulttype);
411 28153 : COMPARE_SCALAR_FIELD(resultcollid);
412 : COMPARE_LOCATION_FIELD(location);
413 :
414 28153 : return true;
415 : }
416 :
417 : static bool
418 5316 : _equalArrayCoerceExpr(const ArrayCoerceExpr *a, const ArrayCoerceExpr *b)
419 : {
420 5316 : COMPARE_NODE_FIELD(arg);
421 5316 : COMPARE_NODE_FIELD(elemexpr);
422 5316 : COMPARE_SCALAR_FIELD(resulttype);
423 5316 : COMPARE_SCALAR_FIELD(resulttypmod);
424 5316 : COMPARE_SCALAR_FIELD(resultcollid);
425 : COMPARE_LOCATION_FIELD(location);
426 :
427 5316 : return true;
428 : }
429 :
430 : static bool
431 66 : _equalConvertRowtypeExpr(const ConvertRowtypeExpr *a, const ConvertRowtypeExpr *b)
432 : {
433 66 : COMPARE_NODE_FIELD(arg);
434 66 : COMPARE_SCALAR_FIELD(resulttype);
435 : COMPARE_LOCATION_FIELD(location);
436 :
437 66 : return true;
438 : }
439 :
440 : static bool
441 9292 : _equalCollateExpr(const CollateExpr *a, const CollateExpr *b)
442 : {
443 9292 : COMPARE_NODE_FIELD(arg);
444 9253 : COMPARE_SCALAR_FIELD(collOid);
445 : COMPARE_LOCATION_FIELD(location);
446 :
447 9253 : return true;
448 : }
449 :
450 : static bool
451 97398 : _equalCaseExpr(const CaseExpr *a, const CaseExpr *b)
452 : {
453 97398 : COMPARE_SCALAR_FIELD(casetype);
454 97398 : COMPARE_SCALAR_FIELD(casecollid);
455 97392 : COMPARE_NODE_FIELD(arg);
456 97374 : COMPARE_NODE_FIELD(args);
457 97336 : COMPARE_NODE_FIELD(defresult);
458 : COMPARE_LOCATION_FIELD(location);
459 :
460 97336 : return true;
461 : }
462 :
463 : static bool
464 179925 : _equalCaseWhen(const CaseWhen *a, const CaseWhen *b)
465 : {
466 179925 : COMPARE_NODE_FIELD(expr);
467 179887 : COMPARE_NODE_FIELD(result);
468 : COMPARE_LOCATION_FIELD(location);
469 :
470 179887 : return true;
471 : }
472 :
473 : static bool
474 26709 : _equalCaseTestExpr(const CaseTestExpr *a, const CaseTestExpr *b)
475 : {
476 26709 : COMPARE_SCALAR_FIELD(typeId);
477 26709 : COMPARE_SCALAR_FIELD(typeMod);
478 26709 : COMPARE_SCALAR_FIELD(collation);
479 :
480 26709 : return true;
481 : }
482 :
483 : static bool
484 26715 : _equalArrayExpr(const ArrayExpr *a, const ArrayExpr *b)
485 : {
486 26715 : COMPARE_SCALAR_FIELD(array_typeid);
487 26715 : COMPARE_SCALAR_FIELD(array_collid);
488 26715 : COMPARE_SCALAR_FIELD(element_typeid);
489 26715 : COMPARE_NODE_FIELD(elements);
490 26715 : COMPARE_SCALAR_FIELD(multidims);
491 : COMPARE_LOCATION_FIELD(list_start);
492 : COMPARE_LOCATION_FIELD(list_end);
493 : COMPARE_LOCATION_FIELD(location);
494 :
495 26715 : return true;
496 : }
497 :
498 : static bool
499 11559 : _equalRowExpr(const RowExpr *a, const RowExpr *b)
500 : {
501 11559 : COMPARE_NODE_FIELD(args);
502 11559 : COMPARE_SCALAR_FIELD(row_typeid);
503 11559 : COMPARE_NODE_FIELD(colnames);
504 : COMPARE_LOCATION_FIELD(location);
505 :
506 11559 : return true;
507 : }
508 :
509 : static bool
510 282 : _equalRowCompareExpr(const RowCompareExpr *a, const RowCompareExpr *b)
511 : {
512 282 : COMPARE_SCALAR_FIELD(cmptype);
513 252 : COMPARE_NODE_FIELD(opnos);
514 252 : COMPARE_NODE_FIELD(opfamilies);
515 252 : COMPARE_NODE_FIELD(inputcollids);
516 252 : COMPARE_NODE_FIELD(largs);
517 252 : COMPARE_NODE_FIELD(rargs);
518 :
519 252 : return true;
520 : }
521 :
522 : static bool
523 8479 : _equalCoalesceExpr(const CoalesceExpr *a, const CoalesceExpr *b)
524 : {
525 8479 : COMPARE_SCALAR_FIELD(coalescetype);
526 8477 : COMPARE_SCALAR_FIELD(coalescecollid);
527 8477 : COMPARE_NODE_FIELD(args);
528 : COMPARE_LOCATION_FIELD(location);
529 :
530 8067 : return true;
531 : }
532 :
533 : static bool
534 583 : _equalMinMaxExpr(const MinMaxExpr *a, const MinMaxExpr *b)
535 : {
536 583 : COMPARE_SCALAR_FIELD(minmaxtype);
537 583 : COMPARE_SCALAR_FIELD(minmaxcollid);
538 583 : COMPARE_SCALAR_FIELD(inputcollid);
539 583 : COMPARE_SCALAR_FIELD(op);
540 583 : COMPARE_NODE_FIELD(args);
541 : COMPARE_LOCATION_FIELD(location);
542 :
543 583 : return true;
544 : }
545 :
546 : static bool
547 7677 : _equalSQLValueFunction(const SQLValueFunction *a, const SQLValueFunction *b)
548 : {
549 7677 : COMPARE_SCALAR_FIELD(op);
550 7647 : COMPARE_SCALAR_FIELD(type);
551 7647 : COMPARE_SCALAR_FIELD(typmod);
552 : COMPARE_LOCATION_FIELD(location);
553 :
554 7647 : return true;
555 : }
556 :
557 : static bool
558 1356 : _equalXmlExpr(const XmlExpr *a, const XmlExpr *b)
559 : {
560 1356 : COMPARE_SCALAR_FIELD(op);
561 1356 : COMPARE_STRING_FIELD(name);
562 1356 : COMPARE_NODE_FIELD(named_args);
563 1356 : COMPARE_NODE_FIELD(arg_names);
564 1356 : COMPARE_NODE_FIELD(args);
565 1356 : COMPARE_SCALAR_FIELD(xmloption);
566 1356 : COMPARE_SCALAR_FIELD(indent);
567 1356 : COMPARE_SCALAR_FIELD(type);
568 1356 : COMPARE_SCALAR_FIELD(typmod);
569 : COMPARE_LOCATION_FIELD(location);
570 :
571 1356 : return true;
572 : }
573 :
574 : static bool
575 14740 : _equalJsonFormat(const JsonFormat *a, const JsonFormat *b)
576 : {
577 14740 : COMPARE_SCALAR_FIELD(format_type);
578 14740 : COMPARE_SCALAR_FIELD(encoding);
579 : COMPARE_LOCATION_FIELD(location);
580 :
581 14740 : return true;
582 : }
583 :
584 : static bool
585 5322 : _equalJsonReturning(const JsonReturning *a, const JsonReturning *b)
586 : {
587 5322 : COMPARE_NODE_FIELD(format);
588 5322 : COMPARE_SCALAR_FIELD(typid);
589 5322 : COMPARE_SCALAR_FIELD(typmod);
590 :
591 5322 : return true;
592 : }
593 :
594 : static bool
595 5348 : _equalJsonValueExpr(const JsonValueExpr *a, const JsonValueExpr *b)
596 : {
597 5348 : COMPARE_NODE_FIELD(raw_expr);
598 5348 : COMPARE_NODE_FIELD(formatted_expr);
599 5348 : COMPARE_NODE_FIELD(format);
600 :
601 5348 : return true;
602 : }
603 :
604 : static bool
605 1366 : _equalJsonConstructorExpr(const JsonConstructorExpr *a, const JsonConstructorExpr *b)
606 : {
607 1366 : COMPARE_SCALAR_FIELD(type);
608 1366 : COMPARE_NODE_FIELD(args);
609 1366 : COMPARE_NODE_FIELD(func);
610 1366 : COMPARE_NODE_FIELD(coercion);
611 1366 : COMPARE_NODE_FIELD(returning);
612 1366 : COMPARE_SCALAR_FIELD(absent_on_null);
613 1366 : COMPARE_SCALAR_FIELD(unique);
614 : COMPARE_LOCATION_FIELD(location);
615 :
616 1366 : return true;
617 : }
618 :
619 : static bool
620 694 : _equalJsonIsPredicate(const JsonIsPredicate *a, const JsonIsPredicate *b)
621 : {
622 694 : COMPARE_NODE_FIELD(expr);
623 694 : COMPARE_NODE_FIELD(format);
624 694 : COMPARE_SCALAR_FIELD(item_type);
625 694 : COMPARE_SCALAR_FIELD(unique_keys);
626 : COMPARE_LOCATION_FIELD(location);
627 :
628 694 : return true;
629 : }
630 :
631 : static bool
632 5382 : _equalJsonBehavior(const JsonBehavior *a, const JsonBehavior *b)
633 : {
634 5382 : COMPARE_SCALAR_FIELD(btype);
635 5382 : COMPARE_NODE_FIELD(expr);
636 5382 : COMPARE_SCALAR_FIELD(coerce);
637 : COMPARE_LOCATION_FIELD(location);
638 :
639 5382 : return true;
640 : }
641 :
642 : static bool
643 2416 : _equalJsonExpr(const JsonExpr *a, const JsonExpr *b)
644 : {
645 2416 : COMPARE_SCALAR_FIELD(op);
646 2416 : COMPARE_STRING_FIELD(column_name);
647 2416 : COMPARE_NODE_FIELD(formatted_expr);
648 2416 : COMPARE_NODE_FIELD(format);
649 2416 : COMPARE_NODE_FIELD(path_spec);
650 2416 : COMPARE_NODE_FIELD(returning);
651 2416 : COMPARE_NODE_FIELD(passing_names);
652 2416 : COMPARE_NODE_FIELD(passing_values);
653 2416 : COMPARE_NODE_FIELD(on_empty);
654 2416 : COMPARE_NODE_FIELD(on_error);
655 2416 : COMPARE_SCALAR_FIELD(use_io_coercion);
656 2416 : COMPARE_SCALAR_FIELD(use_json_coercion);
657 2416 : COMPARE_SCALAR_FIELD(wrapper);
658 2416 : COMPARE_SCALAR_FIELD(omit_quotes);
659 2416 : COMPARE_SCALAR_FIELD(collation);
660 : COMPARE_LOCATION_FIELD(location);
661 :
662 2416 : return true;
663 : }
664 :
665 : static bool
666 562 : _equalJsonTablePath(const JsonTablePath *a, const JsonTablePath *b)
667 : {
668 562 : COMPARE_NODE_FIELD(value);
669 562 : COMPARE_STRING_FIELD(name);
670 :
671 562 : return true;
672 : }
673 :
674 : static bool
675 562 : _equalJsonTablePathScan(const JsonTablePathScan *a, const JsonTablePathScan *b)
676 : {
677 562 : COMPARE_NODE_FIELD(path);
678 562 : COMPARE_SCALAR_FIELD(errorOnError);
679 562 : COMPARE_NODE_FIELD(child);
680 562 : COMPARE_SCALAR_FIELD(colMin);
681 562 : COMPARE_SCALAR_FIELD(colMax);
682 :
683 562 : return true;
684 : }
685 :
686 : static bool
687 60 : _equalJsonTableSiblingJoin(const JsonTableSiblingJoin *a, const JsonTableSiblingJoin *b)
688 : {
689 60 : COMPARE_NODE_FIELD(lplan);
690 60 : COMPARE_NODE_FIELD(rplan);
691 :
692 60 : return true;
693 : }
694 :
695 : static bool
696 40092 : _equalNullTest(const NullTest *a, const NullTest *b)
697 : {
698 40092 : COMPARE_NODE_FIELD(arg);
699 39406 : COMPARE_SCALAR_FIELD(nulltesttype);
700 39353 : COMPARE_SCALAR_FIELD(argisrow);
701 : COMPARE_LOCATION_FIELD(location);
702 :
703 39353 : return true;
704 : }
705 :
706 : static bool
707 2642 : _equalBooleanTest(const BooleanTest *a, const BooleanTest *b)
708 : {
709 2642 : COMPARE_NODE_FIELD(arg);
710 2642 : COMPARE_SCALAR_FIELD(booltesttype);
711 : COMPARE_LOCATION_FIELD(location);
712 :
713 2630 : return true;
714 : }
715 :
716 : static bool
717 3050 : _equalMergeAction(const MergeAction *a, const MergeAction *b)
718 : {
719 3050 : COMPARE_SCALAR_FIELD(matchKind);
720 3050 : COMPARE_SCALAR_FIELD(commandType);
721 3050 : COMPARE_SCALAR_FIELD(override);
722 3050 : COMPARE_NODE_FIELD(qual);
723 3050 : COMPARE_NODE_FIELD(targetList);
724 3050 : COMPARE_NODE_FIELD(updateColnos);
725 :
726 3050 : return true;
727 : }
728 :
729 : static bool
730 36776 : _equalCoerceToDomain(const CoerceToDomain *a, const CoerceToDomain *b)
731 : {
732 36776 : COMPARE_NODE_FIELD(arg);
733 36391 : COMPARE_SCALAR_FIELD(resulttype);
734 36391 : COMPARE_SCALAR_FIELD(resulttypmod);
735 36391 : COMPARE_SCALAR_FIELD(resultcollid);
736 : COMPARE_LOCATION_FIELD(location);
737 :
738 36391 : return true;
739 : }
740 :
741 : static bool
742 0 : _equalCoerceToDomainValue(const CoerceToDomainValue *a, const CoerceToDomainValue *b)
743 : {
744 0 : COMPARE_SCALAR_FIELD(typeId);
745 0 : COMPARE_SCALAR_FIELD(typeMod);
746 0 : COMPARE_SCALAR_FIELD(collation);
747 : COMPARE_LOCATION_FIELD(location);
748 :
749 0 : return true;
750 : }
751 :
752 : static bool
753 1506 : _equalSetToDefault(const SetToDefault *a, const SetToDefault *b)
754 : {
755 1506 : COMPARE_SCALAR_FIELD(typeId);
756 1506 : COMPARE_SCALAR_FIELD(typeMod);
757 1506 : COMPARE_SCALAR_FIELD(collation);
758 : COMPARE_LOCATION_FIELD(location);
759 :
760 1506 : return true;
761 : }
762 :
763 : static bool
764 496 : _equalCurrentOfExpr(const CurrentOfExpr *a, const CurrentOfExpr *b)
765 : {
766 496 : COMPARE_SCALAR_FIELD(cvarno);
767 496 : COMPARE_STRING_FIELD(cursor_name);
768 496 : COMPARE_SCALAR_FIELD(cursor_param);
769 :
770 496 : return true;
771 : }
772 :
773 : static bool
774 444 : _equalNextValueExpr(const NextValueExpr *a, const NextValueExpr *b)
775 : {
776 444 : COMPARE_SCALAR_FIELD(seqid);
777 444 : COMPARE_SCALAR_FIELD(typeId);
778 :
779 444 : return true;
780 : }
781 :
782 : static bool
783 2312 : _equalInferenceElem(const InferenceElem *a, const InferenceElem *b)
784 : {
785 2312 : COMPARE_NODE_FIELD(expr);
786 2312 : COMPARE_SCALAR_FIELD(infercollid);
787 2312 : COMPARE_SCALAR_FIELD(inferopclass);
788 :
789 2312 : return true;
790 : }
791 :
792 : static bool
793 414 : _equalReturningExpr(const ReturningExpr *a, const ReturningExpr *b)
794 : {
795 414 : COMPARE_SCALAR_FIELD(retlevelsup);
796 414 : COMPARE_SCALAR_FIELD(retold);
797 414 : COMPARE_NODE_FIELD(retexpr);
798 :
799 414 : return true;
800 : }
801 :
802 : static bool
803 1667982 : _equalTargetEntry(const TargetEntry *a, const TargetEntry *b)
804 : {
805 1667982 : COMPARE_NODE_FIELD(expr);
806 1665549 : COMPARE_SCALAR_FIELD(resno);
807 1665549 : COMPARE_STRING_FIELD(resname);
808 1665549 : COMPARE_SCALAR_FIELD(ressortgroupref);
809 1665527 : COMPARE_SCALAR_FIELD(resorigtbl);
810 1665527 : COMPARE_SCALAR_FIELD(resorigcol);
811 1665527 : COMPARE_SCALAR_FIELD(resjunk);
812 :
813 1665527 : return true;
814 : }
815 :
816 : static bool
817 547989 : _equalRangeTblRef(const RangeTblRef *a, const RangeTblRef *b)
818 : {
819 547989 : COMPARE_SCALAR_FIELD(rtindex);
820 :
821 547989 : return true;
822 : }
823 :
824 : static bool
825 193188 : _equalJoinExpr(const JoinExpr *a, const JoinExpr *b)
826 : {
827 193188 : COMPARE_SCALAR_FIELD(jointype);
828 193188 : COMPARE_SCALAR_FIELD(isNatural);
829 193188 : COMPARE_NODE_FIELD(larg);
830 193188 : COMPARE_NODE_FIELD(rarg);
831 193188 : COMPARE_NODE_FIELD(usingClause);
832 193188 : COMPARE_NODE_FIELD(join_using_alias);
833 193188 : COMPARE_NODE_FIELD(quals);
834 193188 : COMPARE_NODE_FIELD(alias);
835 193188 : COMPARE_SCALAR_FIELD(rtindex);
836 :
837 193188 : return true;
838 : }
839 :
840 : static bool
841 588003 : _equalFromExpr(const FromExpr *a, const FromExpr *b)
842 : {
843 588003 : COMPARE_NODE_FIELD(fromlist);
844 588003 : COMPARE_NODE_FIELD(quals);
845 :
846 587967 : return true;
847 : }
848 :
849 : static bool
850 2302 : _equalOnConflictExpr(const OnConflictExpr *a, const OnConflictExpr *b)
851 : {
852 2302 : COMPARE_SCALAR_FIELD(action);
853 2302 : COMPARE_NODE_FIELD(arbiterElems);
854 2302 : COMPARE_NODE_FIELD(arbiterWhere);
855 2302 : COMPARE_SCALAR_FIELD(constraint);
856 2302 : COMPARE_SCALAR_FIELD(lockStrength);
857 2302 : COMPARE_NODE_FIELD(onConflictSet);
858 2302 : COMPARE_NODE_FIELD(onConflictWhere);
859 2302 : COMPARE_SCALAR_FIELD(exclRelIndex);
860 2302 : COMPARE_NODE_FIELD(exclRelTlist);
861 :
862 2302 : return true;
863 : }
864 :
865 : static bool
866 998162 : _equalQuery(const Query *a, const Query *b)
867 : {
868 998162 : COMPARE_SCALAR_FIELD(commandType);
869 998162 : COMPARE_SCALAR_FIELD(querySource);
870 998162 : COMPARE_SCALAR_FIELD(canSetTag);
871 998162 : COMPARE_NODE_FIELD(utilityStmt);
872 998162 : COMPARE_SCALAR_FIELD(resultRelation);
873 998162 : COMPARE_SCALAR_FIELD(hasAggs);
874 998162 : COMPARE_SCALAR_FIELD(hasWindowFuncs);
875 998162 : COMPARE_SCALAR_FIELD(hasTargetSRFs);
876 998162 : COMPARE_SCALAR_FIELD(hasSubLinks);
877 998159 : COMPARE_SCALAR_FIELD(hasDistinctOn);
878 998159 : COMPARE_SCALAR_FIELD(hasRecursive);
879 998159 : COMPARE_SCALAR_FIELD(hasModifyingCTE);
880 998159 : COMPARE_SCALAR_FIELD(hasForUpdate);
881 998159 : COMPARE_SCALAR_FIELD(hasRowSecurity);
882 998159 : COMPARE_SCALAR_FIELD(hasGroupRTE);
883 998157 : COMPARE_SCALAR_FIELD(isReturn);
884 998157 : COMPARE_NODE_FIELD(cteList);
885 998154 : COMPARE_NODE_FIELD(rtable);
886 998122 : COMPARE_NODE_FIELD(rteperminfos);
887 998096 : COMPARE_NODE_FIELD(jointree);
888 998060 : COMPARE_NODE_FIELD(mergeActionList);
889 998060 : COMPARE_SCALAR_FIELD(mergeTargetRelation);
890 998060 : COMPARE_NODE_FIELD(mergeJoinCondition);
891 998060 : COMPARE_NODE_FIELD(targetList);
892 998037 : COMPARE_SCALAR_FIELD(override);
893 998037 : COMPARE_NODE_FIELD(onConflict);
894 998037 : COMPARE_STRING_FIELD(returningOldAlias);
895 998037 : COMPARE_STRING_FIELD(returningNewAlias);
896 998037 : COMPARE_NODE_FIELD(returningList);
897 998037 : COMPARE_NODE_FIELD(groupClause);
898 998037 : COMPARE_SCALAR_FIELD(groupDistinct);
899 998037 : COMPARE_SCALAR_FIELD(groupByAll);
900 998037 : COMPARE_NODE_FIELD(groupingSets);
901 998037 : COMPARE_NODE_FIELD(havingQual);
902 998037 : COMPARE_NODE_FIELD(windowClause);
903 998022 : COMPARE_NODE_FIELD(distinctClause);
904 998022 : COMPARE_NODE_FIELD(sortClause);
905 998022 : COMPARE_NODE_FIELD(limitOffset);
906 998022 : COMPARE_NODE_FIELD(limitCount);
907 998022 : COMPARE_SCALAR_FIELD(limitOption);
908 998022 : COMPARE_NODE_FIELD(rowMarks);
909 998022 : COMPARE_NODE_FIELD(setOperations);
910 998022 : COMPARE_NODE_FIELD(constraintDeps);
911 998022 : COMPARE_NODE_FIELD(withCheckOptions);
912 : COMPARE_LOCATION_FIELD(stmt_location);
913 : COMPARE_LOCATION_FIELD(stmt_len);
914 :
915 998022 : return true;
916 : }
917 :
918 : static bool
919 854295 : _equalTypeName(const TypeName *a, const TypeName *b)
920 : {
921 854295 : COMPARE_NODE_FIELD(names);
922 854295 : COMPARE_SCALAR_FIELD(typeOid);
923 854295 : COMPARE_SCALAR_FIELD(setof);
924 854295 : COMPARE_SCALAR_FIELD(pct_type);
925 854295 : COMPARE_NODE_FIELD(typmods);
926 854295 : COMPARE_SCALAR_FIELD(typemod);
927 854295 : COMPARE_NODE_FIELD(arrayBounds);
928 : COMPARE_LOCATION_FIELD(location);
929 :
930 854295 : return true;
931 : }
932 :
933 : static bool
934 2137108 : _equalColumnRef(const ColumnRef *a, const ColumnRef *b)
935 : {
936 2137108 : COMPARE_NODE_FIELD(fields);
937 : COMPARE_LOCATION_FIELD(location);
938 :
939 2137087 : return true;
940 : }
941 :
942 : static bool
943 55428 : _equalParamRef(const ParamRef *a, const ParamRef *b)
944 : {
945 55428 : COMPARE_SCALAR_FIELD(number);
946 : COMPARE_LOCATION_FIELD(location);
947 :
948 55428 : return true;
949 : }
950 :
951 : static bool
952 676850 : _equalA_Expr(const A_Expr *a, const A_Expr *b)
953 : {
954 676850 : COMPARE_SCALAR_FIELD(kind);
955 676850 : COMPARE_NODE_FIELD(name);
956 676850 : COMPARE_NODE_FIELD(lexpr);
957 676844 : COMPARE_NODE_FIELD(rexpr);
958 : COMPARE_LOCATION_FIELD(rexpr_list_start);
959 : COMPARE_LOCATION_FIELD(rexpr_list_end);
960 : COMPARE_LOCATION_FIELD(location);
961 :
962 676844 : return true;
963 : }
964 :
965 : static bool
966 381537 : _equalTypeCast(const TypeCast *a, const TypeCast *b)
967 : {
968 381537 : COMPARE_NODE_FIELD(arg);
969 381537 : COMPARE_NODE_FIELD(typeName);
970 : COMPARE_LOCATION_FIELD(location);
971 :
972 381537 : return true;
973 : }
974 :
975 : static bool
976 11204 : _equalCollateClause(const CollateClause *a, const CollateClause *b)
977 : {
978 11204 : COMPARE_NODE_FIELD(arg);
979 11204 : COMPARE_NODE_FIELD(collname);
980 : COMPARE_LOCATION_FIELD(location);
981 :
982 11204 : return true;
983 : }
984 :
985 : static bool
986 62172 : _equalRoleSpec(const RoleSpec *a, const RoleSpec *b)
987 : {
988 62172 : COMPARE_SCALAR_FIELD(roletype);
989 62172 : COMPARE_STRING_FIELD(rolename);
990 : COMPARE_LOCATION_FIELD(location);
991 :
992 62172 : return true;
993 : }
994 :
995 : static bool
996 426522 : _equalFuncCall(const FuncCall *a, const FuncCall *b)
997 : {
998 426522 : COMPARE_NODE_FIELD(funcname);
999 426522 : COMPARE_NODE_FIELD(args);
1000 426522 : COMPARE_NODE_FIELD(agg_order);
1001 426522 : COMPARE_NODE_FIELD(agg_filter);
1002 426522 : COMPARE_NODE_FIELD(over);
1003 426522 : COMPARE_SCALAR_FIELD(ignore_nulls);
1004 426522 : COMPARE_SCALAR_FIELD(agg_within_group);
1005 426522 : COMPARE_SCALAR_FIELD(agg_star);
1006 426522 : COMPARE_SCALAR_FIELD(agg_distinct);
1007 426522 : COMPARE_SCALAR_FIELD(func_variadic);
1008 : COMPARE_LOCATION_FIELD(location);
1009 :
1010 426522 : return true;
1011 : }
1012 :
1013 : static bool
1014 73146 : _equalA_Star(const A_Star *a, const A_Star *b)
1015 : {
1016 :
1017 73146 : return true;
1018 : }
1019 :
1020 : static bool
1021 16382 : _equalA_Indices(const A_Indices *a, const A_Indices *b)
1022 : {
1023 16382 : COMPARE_SCALAR_FIELD(is_slice);
1024 16382 : COMPARE_NODE_FIELD(lidx);
1025 16382 : COMPARE_NODE_FIELD(uidx);
1026 :
1027 16382 : return true;
1028 : }
1029 :
1030 : static bool
1031 42380 : _equalA_Indirection(const A_Indirection *a, const A_Indirection *b)
1032 : {
1033 42380 : COMPARE_NODE_FIELD(arg);
1034 42380 : COMPARE_NODE_FIELD(indirection);
1035 :
1036 42380 : return true;
1037 : }
1038 :
1039 : static bool
1040 7192 : _equalA_ArrayExpr(const A_ArrayExpr *a, const A_ArrayExpr *b)
1041 : {
1042 7192 : COMPARE_NODE_FIELD(elements);
1043 : COMPARE_LOCATION_FIELD(list_start);
1044 : COMPARE_LOCATION_FIELD(list_end);
1045 : COMPARE_LOCATION_FIELD(location);
1046 :
1047 7192 : return true;
1048 : }
1049 :
1050 : static bool
1051 1353586 : _equalResTarget(const ResTarget *a, const ResTarget *b)
1052 : {
1053 1353586 : COMPARE_STRING_FIELD(name);
1054 1353586 : COMPARE_NODE_FIELD(indirection);
1055 1353586 : COMPARE_NODE_FIELD(val);
1056 : COMPARE_LOCATION_FIELD(location);
1057 :
1058 1353586 : return true;
1059 : }
1060 :
1061 : static bool
1062 402 : _equalMultiAssignRef(const MultiAssignRef *a, const MultiAssignRef *b)
1063 : {
1064 402 : COMPARE_NODE_FIELD(source);
1065 402 : COMPARE_SCALAR_FIELD(colno);
1066 402 : COMPARE_SCALAR_FIELD(ncolumns);
1067 :
1068 402 : return true;
1069 : }
1070 :
1071 : static bool
1072 112879 : _equalSortBy(const SortBy *a, const SortBy *b)
1073 : {
1074 112879 : COMPARE_NODE_FIELD(node);
1075 112867 : COMPARE_SCALAR_FIELD(sortby_dir);
1076 112855 : COMPARE_SCALAR_FIELD(sortby_nulls);
1077 112855 : COMPARE_NODE_FIELD(useOp);
1078 : COMPARE_LOCATION_FIELD(location);
1079 :
1080 112855 : return true;
1081 : }
1082 :
1083 : static bool
1084 4766 : _equalWindowDef(const WindowDef *a, const WindowDef *b)
1085 : {
1086 4766 : COMPARE_STRING_FIELD(name);
1087 4766 : COMPARE_STRING_FIELD(refname);
1088 4766 : COMPARE_NODE_FIELD(partitionClause);
1089 4766 : COMPARE_NODE_FIELD(orderClause);
1090 4766 : COMPARE_SCALAR_FIELD(frameOptions);
1091 4766 : COMPARE_NODE_FIELD(startOffset);
1092 4766 : COMPARE_NODE_FIELD(endOffset);
1093 : COMPARE_LOCATION_FIELD(location);
1094 :
1095 4766 : return true;
1096 : }
1097 :
1098 : static bool
1099 24978 : _equalRangeSubselect(const RangeSubselect *a, const RangeSubselect *b)
1100 : {
1101 24978 : COMPARE_SCALAR_FIELD(lateral);
1102 24978 : COMPARE_NODE_FIELD(subquery);
1103 24978 : COMPARE_NODE_FIELD(alias);
1104 :
1105 24978 : return true;
1106 : }
1107 :
1108 : static bool
1109 54196 : _equalRangeFunction(const RangeFunction *a, const RangeFunction *b)
1110 : {
1111 54196 : COMPARE_SCALAR_FIELD(lateral);
1112 54196 : COMPARE_SCALAR_FIELD(ordinality);
1113 54196 : COMPARE_SCALAR_FIELD(is_rowsfrom);
1114 54196 : COMPARE_NODE_FIELD(functions);
1115 54196 : COMPARE_NODE_FIELD(alias);
1116 54196 : COMPARE_NODE_FIELD(coldeflist);
1117 :
1118 54196 : return true;
1119 : }
1120 :
1121 : static bool
1122 254 : _equalRangeTableFunc(const RangeTableFunc *a, const RangeTableFunc *b)
1123 : {
1124 254 : COMPARE_SCALAR_FIELD(lateral);
1125 254 : COMPARE_NODE_FIELD(docexpr);
1126 254 : COMPARE_NODE_FIELD(rowexpr);
1127 254 : COMPARE_NODE_FIELD(namespaces);
1128 254 : COMPARE_NODE_FIELD(columns);
1129 254 : COMPARE_NODE_FIELD(alias);
1130 : COMPARE_LOCATION_FIELD(location);
1131 :
1132 254 : return true;
1133 : }
1134 :
1135 : static bool
1136 882 : _equalRangeTableFuncCol(const RangeTableFuncCol *a, const RangeTableFuncCol *b)
1137 : {
1138 882 : COMPARE_STRING_FIELD(colname);
1139 882 : COMPARE_NODE_FIELD(typeName);
1140 882 : COMPARE_SCALAR_FIELD(for_ordinality);
1141 882 : COMPARE_SCALAR_FIELD(is_not_null);
1142 882 : COMPARE_NODE_FIELD(colexpr);
1143 882 : COMPARE_NODE_FIELD(coldefexpr);
1144 : COMPARE_LOCATION_FIELD(location);
1145 :
1146 882 : return true;
1147 : }
1148 :
1149 : static bool
1150 292 : _equalRangeTableSample(const RangeTableSample *a, const RangeTableSample *b)
1151 : {
1152 292 : COMPARE_NODE_FIELD(relation);
1153 292 : COMPARE_NODE_FIELD(method);
1154 292 : COMPARE_NODE_FIELD(args);
1155 292 : COMPARE_NODE_FIELD(repeatable);
1156 : COMPARE_LOCATION_FIELD(location);
1157 :
1158 292 : return true;
1159 : }
1160 :
1161 : static bool
1162 148874 : _equalColumnDef(const ColumnDef *a, const ColumnDef *b)
1163 : {
1164 148874 : COMPARE_STRING_FIELD(colname);
1165 148874 : COMPARE_NODE_FIELD(typeName);
1166 148874 : COMPARE_STRING_FIELD(compression);
1167 148874 : COMPARE_SCALAR_FIELD(inhcount);
1168 148874 : COMPARE_SCALAR_FIELD(is_local);
1169 148874 : COMPARE_SCALAR_FIELD(is_not_null);
1170 148874 : COMPARE_SCALAR_FIELD(is_from_type);
1171 148874 : COMPARE_SCALAR_FIELD(storage);
1172 148874 : COMPARE_STRING_FIELD(storage_name);
1173 148874 : COMPARE_NODE_FIELD(raw_default);
1174 148874 : COMPARE_NODE_FIELD(cooked_default);
1175 148874 : COMPARE_SCALAR_FIELD(identity);
1176 148874 : COMPARE_NODE_FIELD(identitySequence);
1177 148874 : COMPARE_SCALAR_FIELD(generated);
1178 148874 : COMPARE_NODE_FIELD(collClause);
1179 148874 : COMPARE_SCALAR_FIELD(collOid);
1180 148874 : COMPARE_NODE_FIELD(constraints);
1181 148874 : COMPARE_NODE_FIELD(fdwoptions);
1182 : COMPARE_LOCATION_FIELD(location);
1183 :
1184 148874 : return true;
1185 : }
1186 :
1187 : static bool
1188 1572 : _equalTableLikeClause(const TableLikeClause *a, const TableLikeClause *b)
1189 : {
1190 1572 : COMPARE_NODE_FIELD(relation);
1191 1572 : COMPARE_SCALAR_FIELD(options);
1192 1572 : COMPARE_SCALAR_FIELD(relationOid);
1193 :
1194 1572 : return true;
1195 : }
1196 :
1197 : static bool
1198 20384 : _equalIndexElem(const IndexElem *a, const IndexElem *b)
1199 : {
1200 20384 : COMPARE_STRING_FIELD(name);
1201 20312 : COMPARE_NODE_FIELD(expr);
1202 20312 : COMPARE_STRING_FIELD(indexcolname);
1203 20312 : COMPARE_NODE_FIELD(collation);
1204 20312 : COMPARE_NODE_FIELD(opclass);
1205 20312 : COMPARE_NODE_FIELD(opclassopts);
1206 20312 : COMPARE_SCALAR_FIELD(ordering);
1207 20312 : COMPARE_SCALAR_FIELD(nulls_ordering);
1208 : COMPARE_LOCATION_FIELD(location);
1209 :
1210 20312 : return true;
1211 : }
1212 :
1213 : static bool
1214 373636 : _equalDefElem(const DefElem *a, const DefElem *b)
1215 : {
1216 373636 : COMPARE_STRING_FIELD(defnamespace);
1217 373636 : COMPARE_STRING_FIELD(defname);
1218 373636 : COMPARE_NODE_FIELD(arg);
1219 373636 : COMPARE_SCALAR_FIELD(defaction);
1220 : COMPARE_LOCATION_FIELD(location);
1221 :
1222 373636 : return true;
1223 : }
1224 :
1225 : static bool
1226 7780 : _equalLockingClause(const LockingClause *a, const LockingClause *b)
1227 : {
1228 7780 : COMPARE_NODE_FIELD(lockedRels);
1229 7780 : COMPARE_SCALAR_FIELD(strength);
1230 7780 : COMPARE_SCALAR_FIELD(waitPolicy);
1231 :
1232 7780 : return true;
1233 : }
1234 :
1235 : static bool
1236 250 : _equalXmlSerialize(const XmlSerialize *a, const XmlSerialize *b)
1237 : {
1238 250 : COMPARE_SCALAR_FIELD(xmloption);
1239 250 : COMPARE_NODE_FIELD(expr);
1240 250 : COMPARE_NODE_FIELD(typeName);
1241 250 : COMPARE_SCALAR_FIELD(indent);
1242 : COMPARE_LOCATION_FIELD(location);
1243 :
1244 250 : return true;
1245 : }
1246 :
1247 : static bool
1248 12180 : _equalPartitionElem(const PartitionElem *a, const PartitionElem *b)
1249 : {
1250 12180 : COMPARE_STRING_FIELD(name);
1251 12180 : COMPARE_NODE_FIELD(expr);
1252 12180 : COMPARE_NODE_FIELD(collation);
1253 12180 : COMPARE_NODE_FIELD(opclass);
1254 : COMPARE_LOCATION_FIELD(location);
1255 :
1256 12180 : return true;
1257 : }
1258 :
1259 : static bool
1260 11208 : _equalPartitionSpec(const PartitionSpec *a, const PartitionSpec *b)
1261 : {
1262 11208 : COMPARE_SCALAR_FIELD(strategy);
1263 11208 : COMPARE_NODE_FIELD(partParams);
1264 : COMPARE_LOCATION_FIELD(location);
1265 :
1266 11208 : return true;
1267 : }
1268 :
1269 : static bool
1270 25696 : _equalPartitionBoundSpec(const PartitionBoundSpec *a, const PartitionBoundSpec *b)
1271 : {
1272 25696 : COMPARE_SCALAR_FIELD(strategy);
1273 25696 : COMPARE_SCALAR_FIELD(is_default);
1274 25696 : COMPARE_SCALAR_FIELD(modulus);
1275 25696 : COMPARE_SCALAR_FIELD(remainder);
1276 25696 : COMPARE_NODE_FIELD(listdatums);
1277 25696 : COMPARE_NODE_FIELD(lowerdatums);
1278 25696 : COMPARE_NODE_FIELD(upperdatums);
1279 : COMPARE_LOCATION_FIELD(location);
1280 :
1281 25696 : return true;
1282 : }
1283 :
1284 : static bool
1285 0 : _equalPartitionRangeDatum(const PartitionRangeDatum *a, const PartitionRangeDatum *b)
1286 : {
1287 0 : COMPARE_SCALAR_FIELD(kind);
1288 0 : COMPARE_NODE_FIELD(value);
1289 : COMPARE_LOCATION_FIELD(location);
1290 :
1291 0 : return true;
1292 : }
1293 :
1294 : static bool
1295 2208 : _equalSinglePartitionSpec(const SinglePartitionSpec *a, const SinglePartitionSpec *b)
1296 : {
1297 2208 : COMPARE_NODE_FIELD(name);
1298 2208 : COMPARE_NODE_FIELD(bound);
1299 :
1300 2208 : return true;
1301 : }
1302 :
1303 : static bool
1304 8494 : _equalPartitionCmd(const PartitionCmd *a, const PartitionCmd *b)
1305 : {
1306 8494 : COMPARE_NODE_FIELD(name);
1307 8494 : COMPARE_NODE_FIELD(bound);
1308 8494 : COMPARE_NODE_FIELD(partlist);
1309 8494 : COMPARE_SCALAR_FIELD(concurrent);
1310 :
1311 8494 : return true;
1312 : }
1313 :
1314 : static bool
1315 728565 : _equalRangeTblEntry(const RangeTblEntry *a, const RangeTblEntry *b)
1316 : {
1317 728565 : COMPARE_NODE_FIELD(alias);
1318 728554 : COMPARE_NODE_FIELD(eref);
1319 728554 : COMPARE_SCALAR_FIELD(rtekind);
1320 728554 : COMPARE_SCALAR_FIELD(relid);
1321 728554 : COMPARE_SCALAR_FIELD(inh);
1322 728554 : COMPARE_SCALAR_FIELD(relkind);
1323 728554 : COMPARE_SCALAR_FIELD(rellockmode);
1324 728554 : COMPARE_SCALAR_FIELD(perminfoindex);
1325 728554 : COMPARE_NODE_FIELD(tablesample);
1326 728554 : COMPARE_NODE_FIELD(subquery);
1327 728551 : COMPARE_SCALAR_FIELD(security_barrier);
1328 728551 : COMPARE_SCALAR_FIELD(jointype);
1329 728551 : COMPARE_SCALAR_FIELD(joinmergedcols);
1330 728551 : COMPARE_NODE_FIELD(joinaliasvars);
1331 728551 : COMPARE_NODE_FIELD(joinleftcols);
1332 728551 : COMPARE_NODE_FIELD(joinrightcols);
1333 728551 : COMPARE_NODE_FIELD(join_using_alias);
1334 728551 : COMPARE_NODE_FIELD(functions);
1335 728551 : COMPARE_SCALAR_FIELD(funcordinality);
1336 728551 : COMPARE_NODE_FIELD(tablefunc);
1337 728551 : COMPARE_NODE_FIELD(values_lists);
1338 728551 : COMPARE_STRING_FIELD(ctename);
1339 728551 : COMPARE_SCALAR_FIELD(ctelevelsup);
1340 728551 : COMPARE_SCALAR_FIELD(self_reference);
1341 728551 : COMPARE_NODE_FIELD(coltypes);
1342 728551 : COMPARE_NODE_FIELD(coltypmods);
1343 728551 : COMPARE_NODE_FIELD(colcollations);
1344 728551 : COMPARE_STRING_FIELD(enrname);
1345 728551 : COMPARE_SCALAR_FIELD(enrtuples);
1346 728551 : COMPARE_NODE_FIELD(groupexprs);
1347 728551 : COMPARE_SCALAR_FIELD(lateral);
1348 728551 : COMPARE_SCALAR_FIELD(inFromCl);
1349 728551 : COMPARE_NODE_FIELD(securityQuals);
1350 :
1351 728551 : return true;
1352 : }
1353 :
1354 : static bool
1355 497119 : _equalRTEPermissionInfo(const RTEPermissionInfo *a, const RTEPermissionInfo *b)
1356 : {
1357 497119 : COMPARE_SCALAR_FIELD(relid);
1358 497119 : COMPARE_SCALAR_FIELD(inh);
1359 497119 : COMPARE_SCALAR_FIELD(requiredPerms);
1360 497119 : COMPARE_SCALAR_FIELD(checkAsUser);
1361 497093 : COMPARE_BITMAPSET_FIELD(selectedCols);
1362 497093 : COMPARE_BITMAPSET_FIELD(insertedCols);
1363 497093 : COMPARE_BITMAPSET_FIELD(updatedCols);
1364 :
1365 497093 : return true;
1366 : }
1367 :
1368 : static bool
1369 51960 : _equalRangeTblFunction(const RangeTblFunction *a, const RangeTblFunction *b)
1370 : {
1371 51960 : COMPARE_NODE_FIELD(funcexpr);
1372 51960 : COMPARE_SCALAR_FIELD(funccolcount);
1373 51960 : COMPARE_NODE_FIELD(funccolnames);
1374 51960 : COMPARE_NODE_FIELD(funccoltypes);
1375 51960 : COMPARE_NODE_FIELD(funccoltypmods);
1376 51960 : COMPARE_NODE_FIELD(funccolcollations);
1377 51960 : COMPARE_BITMAPSET_FIELD(funcparams);
1378 :
1379 51960 : return true;
1380 : }
1381 :
1382 : static bool
1383 220 : _equalTableSampleClause(const TableSampleClause *a, const TableSampleClause *b)
1384 : {
1385 220 : COMPARE_SCALAR_FIELD(tsmhandler);
1386 220 : COMPARE_NODE_FIELD(args);
1387 220 : COMPARE_NODE_FIELD(repeatable);
1388 :
1389 220 : return true;
1390 : }
1391 :
1392 : static bool
1393 5107 : _equalWithCheckOption(const WithCheckOption *a, const WithCheckOption *b)
1394 : {
1395 5107 : COMPARE_SCALAR_FIELD(kind);
1396 3553 : COMPARE_STRING_FIELD(relname);
1397 3553 : COMPARE_STRING_FIELD(polname);
1398 3441 : COMPARE_NODE_FIELD(qual);
1399 3111 : COMPARE_SCALAR_FIELD(cascaded);
1400 :
1401 3111 : return true;
1402 : }
1403 :
1404 : static bool
1405 152990 : _equalSortGroupClause(const SortGroupClause *a, const SortGroupClause *b)
1406 : {
1407 152990 : COMPARE_SCALAR_FIELD(tleSortGroupRef);
1408 152063 : COMPARE_SCALAR_FIELD(eqop);
1409 152063 : COMPARE_SCALAR_FIELD(sortop);
1410 152045 : COMPARE_SCALAR_FIELD(reverse_sort);
1411 152045 : COMPARE_SCALAR_FIELD(nulls_first);
1412 152042 : COMPARE_SCALAR_FIELD(hashable);
1413 :
1414 152042 : return true;
1415 : }
1416 :
1417 : static bool
1418 4932 : _equalGroupingSet(const GroupingSet *a, const GroupingSet *b)
1419 : {
1420 4932 : COMPARE_SCALAR_FIELD(kind);
1421 4932 : COMPARE_NODE_FIELD(content);
1422 : COMPARE_LOCATION_FIELD(location);
1423 :
1424 4932 : return true;
1425 : }
1426 :
1427 : static bool
1428 2994 : _equalWindowClause(const WindowClause *a, const WindowClause *b)
1429 : {
1430 2994 : COMPARE_STRING_FIELD(name);
1431 2994 : COMPARE_STRING_FIELD(refname);
1432 2994 : COMPARE_NODE_FIELD(partitionClause);
1433 2994 : COMPARE_NODE_FIELD(orderClause);
1434 2994 : COMPARE_SCALAR_FIELD(frameOptions);
1435 2979 : COMPARE_NODE_FIELD(startOffset);
1436 2979 : COMPARE_NODE_FIELD(endOffset);
1437 2979 : COMPARE_SCALAR_FIELD(startInRangeFunc);
1438 2979 : COMPARE_SCALAR_FIELD(endInRangeFunc);
1439 2979 : COMPARE_SCALAR_FIELD(inRangeColl);
1440 2979 : COMPARE_SCALAR_FIELD(inRangeAsc);
1441 2979 : COMPARE_SCALAR_FIELD(inRangeNullsFirst);
1442 2979 : COMPARE_SCALAR_FIELD(winref);
1443 2979 : COMPARE_SCALAR_FIELD(copiedOrder);
1444 :
1445 2979 : return true;
1446 : }
1447 :
1448 : static bool
1449 11112 : _equalRowMarkClause(const RowMarkClause *a, const RowMarkClause *b)
1450 : {
1451 11112 : COMPARE_SCALAR_FIELD(rti);
1452 11112 : COMPARE_SCALAR_FIELD(strength);
1453 11112 : COMPARE_SCALAR_FIELD(waitPolicy);
1454 11112 : COMPARE_SCALAR_FIELD(pushedDown);
1455 :
1456 11112 : return true;
1457 : }
1458 :
1459 : static bool
1460 3540 : _equalWithClause(const WithClause *a, const WithClause *b)
1461 : {
1462 3540 : COMPARE_NODE_FIELD(ctes);
1463 3540 : COMPARE_SCALAR_FIELD(recursive);
1464 : COMPARE_LOCATION_FIELD(location);
1465 :
1466 3540 : return true;
1467 : }
1468 :
1469 : static bool
1470 2134 : _equalInferClause(const InferClause *a, const InferClause *b)
1471 : {
1472 2134 : COMPARE_NODE_FIELD(indexElems);
1473 2134 : COMPARE_NODE_FIELD(whereClause);
1474 2134 : COMPARE_STRING_FIELD(conname);
1475 : COMPARE_LOCATION_FIELD(location);
1476 :
1477 2134 : return true;
1478 : }
1479 :
1480 : static bool
1481 2392 : _equalOnConflictClause(const OnConflictClause *a, const OnConflictClause *b)
1482 : {
1483 2392 : COMPARE_SCALAR_FIELD(action);
1484 2392 : COMPARE_NODE_FIELD(infer);
1485 2392 : COMPARE_SCALAR_FIELD(lockStrength);
1486 2392 : COMPARE_NODE_FIELD(targetList);
1487 2392 : COMPARE_NODE_FIELD(whereClause);
1488 : COMPARE_LOCATION_FIELD(location);
1489 :
1490 2392 : return true;
1491 : }
1492 :
1493 : static bool
1494 210 : _equalCTESearchClause(const CTESearchClause *a, const CTESearchClause *b)
1495 : {
1496 210 : COMPARE_NODE_FIELD(search_col_list);
1497 210 : COMPARE_SCALAR_FIELD(search_breadth_first);
1498 210 : COMPARE_STRING_FIELD(search_seq_column);
1499 : COMPARE_LOCATION_FIELD(location);
1500 :
1501 210 : return true;
1502 : }
1503 :
1504 : static bool
1505 210 : _equalCTECycleClause(const CTECycleClause *a, const CTECycleClause *b)
1506 : {
1507 210 : COMPARE_NODE_FIELD(cycle_col_list);
1508 210 : COMPARE_STRING_FIELD(cycle_mark_column);
1509 210 : COMPARE_NODE_FIELD(cycle_mark_value);
1510 210 : COMPARE_NODE_FIELD(cycle_mark_default);
1511 210 : COMPARE_STRING_FIELD(cycle_path_column);
1512 : COMPARE_LOCATION_FIELD(location);
1513 210 : COMPARE_SCALAR_FIELD(cycle_mark_type);
1514 210 : COMPARE_SCALAR_FIELD(cycle_mark_typmod);
1515 210 : COMPARE_SCALAR_FIELD(cycle_mark_collation);
1516 210 : COMPARE_SCALAR_FIELD(cycle_mark_neop);
1517 :
1518 210 : return true;
1519 : }
1520 :
1521 : static bool
1522 9100 : _equalCommonTableExpr(const CommonTableExpr *a, const CommonTableExpr *b)
1523 : {
1524 9100 : COMPARE_STRING_FIELD(ctename);
1525 9100 : COMPARE_NODE_FIELD(aliascolnames);
1526 9100 : COMPARE_SCALAR_FIELD(ctematerialized);
1527 9100 : COMPARE_NODE_FIELD(ctequery);
1528 9097 : COMPARE_NODE_FIELD(search_clause);
1529 9097 : COMPARE_NODE_FIELD(cycle_clause);
1530 : COMPARE_LOCATION_FIELD(location);
1531 9097 : COMPARE_SCALAR_FIELD(cterecursive);
1532 9097 : COMPARE_SCALAR_FIELD(cterefcount);
1533 9097 : COMPARE_NODE_FIELD(ctecolnames);
1534 9097 : COMPARE_NODE_FIELD(ctecoltypes);
1535 9097 : COMPARE_NODE_FIELD(ctecoltypmods);
1536 9097 : COMPARE_NODE_FIELD(ctecolcollations);
1537 :
1538 9097 : return true;
1539 : }
1540 :
1541 : static bool
1542 3154 : _equalMergeWhenClause(const MergeWhenClause *a, const MergeWhenClause *b)
1543 : {
1544 3154 : COMPARE_SCALAR_FIELD(matchKind);
1545 3154 : COMPARE_SCALAR_FIELD(commandType);
1546 3154 : COMPARE_SCALAR_FIELD(override);
1547 3154 : COMPARE_NODE_FIELD(condition);
1548 3154 : COMPARE_NODE_FIELD(targetList);
1549 3154 : COMPARE_NODE_FIELD(values);
1550 :
1551 3154 : return true;
1552 : }
1553 :
1554 : static bool
1555 150 : _equalReturningOption(const ReturningOption *a, const ReturningOption *b)
1556 : {
1557 150 : COMPARE_SCALAR_FIELD(option);
1558 150 : COMPARE_STRING_FIELD(value);
1559 : COMPARE_LOCATION_FIELD(location);
1560 :
1561 150 : return true;
1562 : }
1563 :
1564 : static bool
1565 3802 : _equalReturningClause(const ReturningClause *a, const ReturningClause *b)
1566 : {
1567 3802 : COMPARE_NODE_FIELD(options);
1568 3802 : COMPARE_NODE_FIELD(exprs);
1569 :
1570 3802 : return true;
1571 : }
1572 :
1573 : static bool
1574 1212 : _equalTriggerTransition(const TriggerTransition *a, const TriggerTransition *b)
1575 : {
1576 1212 : COMPARE_STRING_FIELD(name);
1577 1212 : COMPARE_SCALAR_FIELD(isNew);
1578 1212 : COMPARE_SCALAR_FIELD(isTable);
1579 :
1580 1212 : return true;
1581 : }
1582 :
1583 : static bool
1584 1540 : _equalJsonOutput(const JsonOutput *a, const JsonOutput *b)
1585 : {
1586 1540 : COMPARE_NODE_FIELD(typeName);
1587 1540 : COMPARE_NODE_FIELD(returning);
1588 :
1589 1540 : return true;
1590 : }
1591 :
1592 : static bool
1593 630 : _equalJsonArgument(const JsonArgument *a, const JsonArgument *b)
1594 : {
1595 630 : COMPARE_NODE_FIELD(val);
1596 630 : COMPARE_STRING_FIELD(name);
1597 :
1598 630 : return true;
1599 : }
1600 :
1601 : static bool
1602 2052 : _equalJsonFuncExpr(const JsonFuncExpr *a, const JsonFuncExpr *b)
1603 : {
1604 2052 : COMPARE_SCALAR_FIELD(op);
1605 2052 : COMPARE_STRING_FIELD(column_name);
1606 2052 : COMPARE_NODE_FIELD(context_item);
1607 2052 : COMPARE_NODE_FIELD(pathspec);
1608 2052 : COMPARE_NODE_FIELD(passing);
1609 2052 : COMPARE_NODE_FIELD(output);
1610 2052 : COMPARE_NODE_FIELD(on_empty);
1611 2052 : COMPARE_NODE_FIELD(on_error);
1612 2052 : COMPARE_SCALAR_FIELD(wrapper);
1613 2052 : COMPARE_SCALAR_FIELD(quotes);
1614 : COMPARE_LOCATION_FIELD(location);
1615 :
1616 2052 : return true;
1617 : }
1618 :
1619 : static bool
1620 1984 : _equalJsonTablePathSpec(const JsonTablePathSpec *a, const JsonTablePathSpec *b)
1621 : {
1622 1984 : COMPARE_NODE_FIELD(string);
1623 1984 : COMPARE_STRING_FIELD(name);
1624 : COMPARE_LOCATION_FIELD(name_location);
1625 : COMPARE_LOCATION_FIELD(location);
1626 :
1627 1984 : return true;
1628 : }
1629 :
1630 : static bool
1631 602 : _equalJsonTable(const JsonTable *a, const JsonTable *b)
1632 : {
1633 602 : COMPARE_NODE_FIELD(context_item);
1634 602 : COMPARE_NODE_FIELD(pathspec);
1635 602 : COMPARE_NODE_FIELD(passing);
1636 602 : COMPARE_NODE_FIELD(columns);
1637 602 : COMPARE_NODE_FIELD(on_error);
1638 602 : COMPARE_NODE_FIELD(alias);
1639 602 : COMPARE_SCALAR_FIELD(lateral);
1640 : COMPARE_LOCATION_FIELD(location);
1641 :
1642 602 : return true;
1643 : }
1644 :
1645 : static bool
1646 1660 : _equalJsonTableColumn(const JsonTableColumn *a, const JsonTableColumn *b)
1647 : {
1648 1660 : COMPARE_SCALAR_FIELD(coltype);
1649 1660 : COMPARE_STRING_FIELD(name);
1650 1660 : COMPARE_NODE_FIELD(typeName);
1651 1660 : COMPARE_NODE_FIELD(pathspec);
1652 1660 : COMPARE_NODE_FIELD(format);
1653 1660 : COMPARE_SCALAR_FIELD(wrapper);
1654 1660 : COMPARE_SCALAR_FIELD(quotes);
1655 1660 : COMPARE_NODE_FIELD(columns);
1656 1660 : COMPARE_NODE_FIELD(on_empty);
1657 1660 : COMPARE_NODE_FIELD(on_error);
1658 : COMPARE_LOCATION_FIELD(location);
1659 :
1660 1660 : return true;
1661 : }
1662 :
1663 : static bool
1664 826 : _equalJsonKeyValue(const JsonKeyValue *a, const JsonKeyValue *b)
1665 : {
1666 826 : COMPARE_NODE_FIELD(key);
1667 826 : COMPARE_NODE_FIELD(value);
1668 :
1669 826 : return true;
1670 : }
1671 :
1672 : static bool
1673 164 : _equalJsonParseExpr(const JsonParseExpr *a, const JsonParseExpr *b)
1674 : {
1675 164 : COMPARE_NODE_FIELD(expr);
1676 164 : COMPARE_NODE_FIELD(output);
1677 164 : COMPARE_SCALAR_FIELD(unique_keys);
1678 : COMPARE_LOCATION_FIELD(location);
1679 :
1680 164 : return true;
1681 : }
1682 :
1683 : static bool
1684 112 : _equalJsonScalarExpr(const JsonScalarExpr *a, const JsonScalarExpr *b)
1685 : {
1686 112 : COMPARE_NODE_FIELD(expr);
1687 112 : COMPARE_NODE_FIELD(output);
1688 : COMPARE_LOCATION_FIELD(location);
1689 :
1690 112 : return true;
1691 : }
1692 :
1693 : static bool
1694 108 : _equalJsonSerializeExpr(const JsonSerializeExpr *a, const JsonSerializeExpr *b)
1695 : {
1696 108 : COMPARE_NODE_FIELD(expr);
1697 108 : COMPARE_NODE_FIELD(output);
1698 : COMPARE_LOCATION_FIELD(location);
1699 :
1700 108 : return true;
1701 : }
1702 :
1703 : static bool
1704 446 : _equalJsonObjectConstructor(const JsonObjectConstructor *a, const JsonObjectConstructor *b)
1705 : {
1706 446 : COMPARE_NODE_FIELD(exprs);
1707 446 : COMPARE_NODE_FIELD(output);
1708 446 : COMPARE_SCALAR_FIELD(absent_on_null);
1709 446 : COMPARE_SCALAR_FIELD(unique);
1710 : COMPARE_LOCATION_FIELD(location);
1711 :
1712 446 : return true;
1713 : }
1714 :
1715 : static bool
1716 212 : _equalJsonArrayConstructor(const JsonArrayConstructor *a, const JsonArrayConstructor *b)
1717 : {
1718 212 : COMPARE_NODE_FIELD(exprs);
1719 212 : COMPARE_NODE_FIELD(output);
1720 212 : COMPARE_SCALAR_FIELD(absent_on_null);
1721 : COMPARE_LOCATION_FIELD(location);
1722 :
1723 212 : return true;
1724 : }
1725 :
1726 : static bool
1727 66 : _equalJsonArrayQueryConstructor(const JsonArrayQueryConstructor *a, const JsonArrayQueryConstructor *b)
1728 : {
1729 66 : COMPARE_NODE_FIELD(query);
1730 66 : COMPARE_NODE_FIELD(output);
1731 66 : COMPARE_NODE_FIELD(format);
1732 66 : COMPARE_SCALAR_FIELD(absent_on_null);
1733 : COMPARE_LOCATION_FIELD(location);
1734 :
1735 66 : return true;
1736 : }
1737 :
1738 : static bool
1739 372 : _equalJsonAggConstructor(const JsonAggConstructor *a, const JsonAggConstructor *b)
1740 : {
1741 372 : COMPARE_NODE_FIELD(output);
1742 372 : COMPARE_NODE_FIELD(agg_filter);
1743 372 : COMPARE_NODE_FIELD(agg_order);
1744 372 : COMPARE_NODE_FIELD(over);
1745 : COMPARE_LOCATION_FIELD(location);
1746 :
1747 372 : return true;
1748 : }
1749 :
1750 : static bool
1751 210 : _equalJsonObjectAgg(const JsonObjectAgg *a, const JsonObjectAgg *b)
1752 : {
1753 210 : COMPARE_NODE_FIELD(constructor);
1754 210 : COMPARE_NODE_FIELD(arg);
1755 210 : COMPARE_SCALAR_FIELD(absent_on_null);
1756 210 : COMPARE_SCALAR_FIELD(unique);
1757 :
1758 210 : return true;
1759 : }
1760 :
1761 : static bool
1762 162 : _equalJsonArrayAgg(const JsonArrayAgg *a, const JsonArrayAgg *b)
1763 : {
1764 162 : COMPARE_NODE_FIELD(constructor);
1765 162 : COMPARE_NODE_FIELD(arg);
1766 162 : COMPARE_SCALAR_FIELD(absent_on_null);
1767 :
1768 162 : return true;
1769 : }
1770 :
1771 : static bool
1772 770422 : _equalRawStmt(const RawStmt *a, const RawStmt *b)
1773 : {
1774 770422 : COMPARE_NODE_FIELD(stmt);
1775 : COMPARE_LOCATION_FIELD(stmt_location);
1776 : COMPARE_LOCATION_FIELD(stmt_len);
1777 :
1778 770422 : return true;
1779 : }
1780 :
1781 : static bool
1782 71914 : _equalInsertStmt(const InsertStmt *a, const InsertStmt *b)
1783 : {
1784 71914 : COMPARE_NODE_FIELD(relation);
1785 71914 : COMPARE_NODE_FIELD(cols);
1786 71914 : COMPARE_NODE_FIELD(selectStmt);
1787 71914 : COMPARE_NODE_FIELD(onConflictClause);
1788 71914 : COMPARE_NODE_FIELD(returningClause);
1789 71914 : COMPARE_NODE_FIELD(withClause);
1790 71914 : COMPARE_SCALAR_FIELD(override);
1791 :
1792 71914 : return true;
1793 : }
1794 :
1795 : static bool
1796 4550 : _equalDeleteStmt(const DeleteStmt *a, const DeleteStmt *b)
1797 : {
1798 4550 : COMPARE_NODE_FIELD(relation);
1799 4550 : COMPARE_NODE_FIELD(usingClause);
1800 4550 : COMPARE_NODE_FIELD(whereClause);
1801 4550 : COMPARE_NODE_FIELD(returningClause);
1802 4550 : COMPARE_NODE_FIELD(withClause);
1803 :
1804 4550 : return true;
1805 : }
1806 :
1807 : static bool
1808 14520 : _equalUpdateStmt(const UpdateStmt *a, const UpdateStmt *b)
1809 : {
1810 14520 : COMPARE_NODE_FIELD(relation);
1811 14520 : COMPARE_NODE_FIELD(targetList);
1812 14520 : COMPARE_NODE_FIELD(whereClause);
1813 14520 : COMPARE_NODE_FIELD(fromClause);
1814 14520 : COMPARE_NODE_FIELD(returningClause);
1815 14520 : COMPARE_NODE_FIELD(withClause);
1816 :
1817 14520 : return true;
1818 : }
1819 :
1820 : static bool
1821 2056 : _equalMergeStmt(const MergeStmt *a, const MergeStmt *b)
1822 : {
1823 2056 : COMPARE_NODE_FIELD(relation);
1824 2056 : COMPARE_NODE_FIELD(sourceRelation);
1825 2056 : COMPARE_NODE_FIELD(joinCondition);
1826 2056 : COMPARE_NODE_FIELD(mergeWhenClauses);
1827 2056 : COMPARE_NODE_FIELD(returningClause);
1828 2056 : COMPARE_NODE_FIELD(withClause);
1829 :
1830 2056 : return true;
1831 : }
1832 :
1833 : static bool
1834 539198 : _equalSelectStmt(const SelectStmt *a, const SelectStmt *b)
1835 : {
1836 539198 : COMPARE_NODE_FIELD(distinctClause);
1837 539198 : COMPARE_NODE_FIELD(intoClause);
1838 539198 : COMPARE_NODE_FIELD(targetList);
1839 539198 : COMPARE_NODE_FIELD(fromClause);
1840 539198 : COMPARE_NODE_FIELD(whereClause);
1841 539198 : COMPARE_NODE_FIELD(groupClause);
1842 539198 : COMPARE_SCALAR_FIELD(groupDistinct);
1843 539198 : COMPARE_SCALAR_FIELD(groupByAll);
1844 539198 : COMPARE_NODE_FIELD(havingClause);
1845 539198 : COMPARE_NODE_FIELD(windowClause);
1846 539198 : COMPARE_NODE_FIELD(valuesLists);
1847 539198 : COMPARE_NODE_FIELD(sortClause);
1848 539198 : COMPARE_NODE_FIELD(limitOffset);
1849 539198 : COMPARE_NODE_FIELD(limitCount);
1850 539198 : COMPARE_SCALAR_FIELD(limitOption);
1851 539198 : COMPARE_NODE_FIELD(lockingClause);
1852 539198 : COMPARE_NODE_FIELD(withClause);
1853 539198 : COMPARE_SCALAR_FIELD(op);
1854 539198 : COMPARE_SCALAR_FIELD(all);
1855 539198 : COMPARE_NODE_FIELD(larg);
1856 539198 : COMPARE_NODE_FIELD(rarg);
1857 :
1858 539198 : return true;
1859 : }
1860 :
1861 : static bool
1862 20751 : _equalSetOperationStmt(const SetOperationStmt *a, const SetOperationStmt *b)
1863 : {
1864 20751 : COMPARE_SCALAR_FIELD(op);
1865 20751 : COMPARE_SCALAR_FIELD(all);
1866 20751 : COMPARE_NODE_FIELD(larg);
1867 20751 : COMPARE_NODE_FIELD(rarg);
1868 20751 : COMPARE_NODE_FIELD(colTypes);
1869 20751 : COMPARE_NODE_FIELD(colTypmods);
1870 20751 : COMPARE_NODE_FIELD(colCollations);
1871 20751 : COMPARE_NODE_FIELD(groupClauses);
1872 :
1873 20751 : return true;
1874 : }
1875 :
1876 : static bool
1877 9964 : _equalReturnStmt(const ReturnStmt *a, const ReturnStmt *b)
1878 : {
1879 9964 : COMPARE_NODE_FIELD(returnval);
1880 :
1881 9964 : return true;
1882 : }
1883 :
1884 : static bool
1885 0 : _equalPLAssignStmt(const PLAssignStmt *a, const PLAssignStmt *b)
1886 : {
1887 0 : COMPARE_STRING_FIELD(name);
1888 0 : COMPARE_NODE_FIELD(indirection);
1889 0 : COMPARE_SCALAR_FIELD(nnames);
1890 0 : COMPARE_NODE_FIELD(val);
1891 : COMPARE_LOCATION_FIELD(location);
1892 :
1893 0 : return true;
1894 : }
1895 :
1896 : static bool
1897 2250 : _equalCreateSchemaStmt(const CreateSchemaStmt *a, const CreateSchemaStmt *b)
1898 : {
1899 2250 : COMPARE_STRING_FIELD(schemaname);
1900 2250 : COMPARE_NODE_FIELD(authrole);
1901 2250 : COMPARE_NODE_FIELD(schemaElts);
1902 2250 : COMPARE_SCALAR_FIELD(if_not_exists);
1903 :
1904 2250 : return true;
1905 : }
1906 :
1907 : static bool
1908 64016 : _equalAlterTableStmt(const AlterTableStmt *a, const AlterTableStmt *b)
1909 : {
1910 64016 : COMPARE_NODE_FIELD(relation);
1911 64016 : COMPARE_NODE_FIELD(cmds);
1912 64016 : COMPARE_SCALAR_FIELD(objtype);
1913 64016 : COMPARE_SCALAR_FIELD(missing_ok);
1914 :
1915 64016 : return true;
1916 : }
1917 :
1918 : static bool
1919 66032 : _equalAlterTableCmd(const AlterTableCmd *a, const AlterTableCmd *b)
1920 : {
1921 66032 : COMPARE_SCALAR_FIELD(subtype);
1922 66032 : COMPARE_STRING_FIELD(name);
1923 66032 : COMPARE_SCALAR_FIELD(num);
1924 66032 : COMPARE_NODE_FIELD(newowner);
1925 66032 : COMPARE_NODE_FIELD(def);
1926 66032 : COMPARE_SCALAR_FIELD(behavior);
1927 66032 : COMPARE_SCALAR_FIELD(missing_ok);
1928 66032 : COMPARE_SCALAR_FIELD(recurse);
1929 :
1930 66032 : return true;
1931 : }
1932 :
1933 : static bool
1934 600 : _equalATAlterConstraint(const ATAlterConstraint *a, const ATAlterConstraint *b)
1935 : {
1936 600 : COMPARE_STRING_FIELD(conname);
1937 600 : COMPARE_SCALAR_FIELD(alterEnforceability);
1938 600 : COMPARE_SCALAR_FIELD(is_enforced);
1939 600 : COMPARE_SCALAR_FIELD(alterDeferrability);
1940 600 : COMPARE_SCALAR_FIELD(deferrable);
1941 600 : COMPARE_SCALAR_FIELD(initdeferred);
1942 600 : COMPARE_SCALAR_FIELD(alterInheritability);
1943 600 : COMPARE_SCALAR_FIELD(noinherit);
1944 :
1945 600 : return true;
1946 : }
1947 :
1948 : static bool
1949 988 : _equalReplicaIdentityStmt(const ReplicaIdentityStmt *a, const ReplicaIdentityStmt *b)
1950 : {
1951 988 : COMPARE_SCALAR_FIELD(identity_type);
1952 988 : COMPARE_STRING_FIELD(name);
1953 :
1954 988 : return true;
1955 : }
1956 :
1957 : static bool
1958 12 : _equalAlterCollationStmt(const AlterCollationStmt *a, const AlterCollationStmt *b)
1959 : {
1960 12 : COMPARE_NODE_FIELD(collname);
1961 :
1962 12 : return true;
1963 : }
1964 :
1965 : static bool
1966 580 : _equalAlterDomainStmt(const AlterDomainStmt *a, const AlterDomainStmt *b)
1967 : {
1968 580 : COMPARE_SCALAR_FIELD(subtype);
1969 580 : COMPARE_NODE_FIELD(typeName);
1970 580 : COMPARE_STRING_FIELD(name);
1971 580 : COMPARE_NODE_FIELD(def);
1972 580 : COMPARE_SCALAR_FIELD(behavior);
1973 580 : COMPARE_SCALAR_FIELD(missing_ok);
1974 :
1975 580 : return true;
1976 : }
1977 :
1978 : static bool
1979 43122 : _equalGrantStmt(const GrantStmt *a, const GrantStmt *b)
1980 : {
1981 43122 : COMPARE_SCALAR_FIELD(is_grant);
1982 43122 : COMPARE_SCALAR_FIELD(targtype);
1983 43122 : COMPARE_SCALAR_FIELD(objtype);
1984 43122 : COMPARE_NODE_FIELD(objects);
1985 43122 : COMPARE_NODE_FIELD(privileges);
1986 43122 : COMPARE_NODE_FIELD(grantees);
1987 43122 : COMPARE_SCALAR_FIELD(grant_option);
1988 43122 : COMPARE_NODE_FIELD(grantor);
1989 43122 : COMPARE_SCALAR_FIELD(behavior);
1990 :
1991 43122 : return true;
1992 : }
1993 :
1994 : static bool
1995 44818 : _equalObjectWithArgs(const ObjectWithArgs *a, const ObjectWithArgs *b)
1996 : {
1997 44818 : COMPARE_NODE_FIELD(objname);
1998 44818 : COMPARE_NODE_FIELD(objargs);
1999 44818 : COMPARE_NODE_FIELD(objfuncargs);
2000 44818 : COMPARE_SCALAR_FIELD(args_unspecified);
2001 :
2002 44818 : return true;
2003 : }
2004 :
2005 : static bool
2006 40310 : _equalAccessPriv(const AccessPriv *a, const AccessPriv *b)
2007 : {
2008 40310 : COMPARE_STRING_FIELD(priv_name);
2009 40310 : COMPARE_NODE_FIELD(cols);
2010 :
2011 40310 : return true;
2012 : }
2013 :
2014 : static bool
2015 1824 : _equalGrantRoleStmt(const GrantRoleStmt *a, const GrantRoleStmt *b)
2016 : {
2017 1824 : COMPARE_NODE_FIELD(granted_roles);
2018 1824 : COMPARE_NODE_FIELD(grantee_roles);
2019 1824 : COMPARE_SCALAR_FIELD(is_grant);
2020 1824 : COMPARE_NODE_FIELD(opt);
2021 1824 : COMPARE_NODE_FIELD(grantor);
2022 1824 : COMPARE_SCALAR_FIELD(behavior);
2023 :
2024 1824 : return true;
2025 : }
2026 :
2027 : static bool
2028 412 : _equalAlterDefaultPrivilegesStmt(const AlterDefaultPrivilegesStmt *a, const AlterDefaultPrivilegesStmt *b)
2029 : {
2030 412 : COMPARE_NODE_FIELD(options);
2031 412 : COMPARE_NODE_FIELD(action);
2032 :
2033 412 : return true;
2034 : }
2035 :
2036 : static bool
2037 22660 : _equalCopyStmt(const CopyStmt *a, const CopyStmt *b)
2038 : {
2039 22660 : COMPARE_NODE_FIELD(relation);
2040 22660 : COMPARE_NODE_FIELD(query);
2041 22660 : COMPARE_NODE_FIELD(attlist);
2042 22660 : COMPARE_SCALAR_FIELD(is_from);
2043 22660 : COMPARE_SCALAR_FIELD(is_program);
2044 22660 : COMPARE_STRING_FIELD(filename);
2045 22660 : COMPARE_NODE_FIELD(options);
2046 22660 : COMPARE_NODE_FIELD(whereClause);
2047 :
2048 22660 : return true;
2049 : }
2050 :
2051 : static bool
2052 61394 : _equalVariableSetStmt(const VariableSetStmt *a, const VariableSetStmt *b)
2053 : {
2054 61394 : COMPARE_SCALAR_FIELD(kind);
2055 61394 : COMPARE_STRING_FIELD(name);
2056 61394 : COMPARE_NODE_FIELD(args);
2057 61394 : COMPARE_SCALAR_FIELD(jumble_args);
2058 61394 : COMPARE_SCALAR_FIELD(is_local);
2059 : COMPARE_LOCATION_FIELD(location);
2060 :
2061 61394 : return true;
2062 : }
2063 :
2064 : static bool
2065 1800 : _equalVariableShowStmt(const VariableShowStmt *a, const VariableShowStmt *b)
2066 : {
2067 1800 : COMPARE_STRING_FIELD(name);
2068 :
2069 1800 : return true;
2070 : }
2071 :
2072 : static bool
2073 80226 : _equalCreateStmt(const CreateStmt *a, const CreateStmt *b)
2074 : {
2075 80226 : COMPARE_NODE_FIELD(relation);
2076 80226 : COMPARE_NODE_FIELD(tableElts);
2077 80226 : COMPARE_NODE_FIELD(inhRelations);
2078 80226 : COMPARE_NODE_FIELD(partbound);
2079 80226 : COMPARE_NODE_FIELD(partspec);
2080 80226 : COMPARE_NODE_FIELD(ofTypename);
2081 80226 : COMPARE_NODE_FIELD(constraints);
2082 80226 : COMPARE_NODE_FIELD(nnconstraints);
2083 80226 : COMPARE_NODE_FIELD(options);
2084 80226 : COMPARE_SCALAR_FIELD(oncommit);
2085 80226 : COMPARE_STRING_FIELD(tablespacename);
2086 80226 : COMPARE_STRING_FIELD(accessMethod);
2087 80226 : COMPARE_SCALAR_FIELD(if_not_exists);
2088 :
2089 80226 : return true;
2090 : }
2091 :
2092 : static bool
2093 74416 : _equalConstraint(const Constraint *a, const Constraint *b)
2094 : {
2095 74416 : COMPARE_SCALAR_FIELD(contype);
2096 74416 : COMPARE_STRING_FIELD(conname);
2097 74416 : COMPARE_SCALAR_FIELD(deferrable);
2098 74416 : COMPARE_SCALAR_FIELD(initdeferred);
2099 74416 : COMPARE_SCALAR_FIELD(is_enforced);
2100 74416 : COMPARE_SCALAR_FIELD(skip_validation);
2101 74416 : COMPARE_SCALAR_FIELD(initially_valid);
2102 74416 : COMPARE_SCALAR_FIELD(is_no_inherit);
2103 74416 : COMPARE_NODE_FIELD(raw_expr);
2104 74416 : COMPARE_STRING_FIELD(cooked_expr);
2105 74416 : COMPARE_SCALAR_FIELD(generated_when);
2106 74416 : COMPARE_SCALAR_FIELD(generated_kind);
2107 74416 : COMPARE_SCALAR_FIELD(nulls_not_distinct);
2108 74416 : COMPARE_NODE_FIELD(keys);
2109 74416 : COMPARE_SCALAR_FIELD(without_overlaps);
2110 74416 : COMPARE_NODE_FIELD(including);
2111 74416 : COMPARE_NODE_FIELD(exclusions);
2112 74416 : COMPARE_NODE_FIELD(options);
2113 74416 : COMPARE_STRING_FIELD(indexname);
2114 74416 : COMPARE_STRING_FIELD(indexspace);
2115 74416 : COMPARE_SCALAR_FIELD(reset_default_tblspc);
2116 74416 : COMPARE_STRING_FIELD(access_method);
2117 74416 : COMPARE_NODE_FIELD(where_clause);
2118 74416 : COMPARE_NODE_FIELD(pktable);
2119 74416 : COMPARE_NODE_FIELD(fk_attrs);
2120 74416 : COMPARE_NODE_FIELD(pk_attrs);
2121 74416 : COMPARE_SCALAR_FIELD(fk_with_period);
2122 74416 : COMPARE_SCALAR_FIELD(pk_with_period);
2123 74416 : COMPARE_SCALAR_FIELD(fk_matchtype);
2124 74416 : COMPARE_SCALAR_FIELD(fk_upd_action);
2125 74416 : COMPARE_SCALAR_FIELD(fk_del_action);
2126 74416 : COMPARE_NODE_FIELD(fk_del_set_cols);
2127 74416 : COMPARE_NODE_FIELD(old_conpfeqop);
2128 74416 : COMPARE_SCALAR_FIELD(old_pktable_oid);
2129 : COMPARE_LOCATION_FIELD(location);
2130 :
2131 74416 : return true;
2132 : }
2133 :
2134 : static bool
2135 264 : _equalCreateTableSpaceStmt(const CreateTableSpaceStmt *a, const CreateTableSpaceStmt *b)
2136 : {
2137 264 : COMPARE_STRING_FIELD(tablespacename);
2138 264 : COMPARE_NODE_FIELD(owner);
2139 264 : COMPARE_STRING_FIELD(location);
2140 264 : COMPARE_NODE_FIELD(options);
2141 :
2142 264 : return true;
2143 : }
2144 :
2145 : static bool
2146 128 : _equalDropTableSpaceStmt(const DropTableSpaceStmt *a, const DropTableSpaceStmt *b)
2147 : {
2148 128 : COMPARE_STRING_FIELD(tablespacename);
2149 128 : COMPARE_SCALAR_FIELD(missing_ok);
2150 :
2151 128 : return true;
2152 : }
2153 :
2154 : static bool
2155 48 : _equalAlterTableSpaceOptionsStmt(const AlterTableSpaceOptionsStmt *a, const AlterTableSpaceOptionsStmt *b)
2156 : {
2157 48 : COMPARE_STRING_FIELD(tablespacename);
2158 48 : COMPARE_NODE_FIELD(options);
2159 48 : COMPARE_SCALAR_FIELD(isReset);
2160 :
2161 48 : return true;
2162 : }
2163 :
2164 : static bool
2165 60 : _equalAlterTableMoveAllStmt(const AlterTableMoveAllStmt *a, const AlterTableMoveAllStmt *b)
2166 : {
2167 60 : COMPARE_STRING_FIELD(orig_tablespacename);
2168 60 : COMPARE_SCALAR_FIELD(objtype);
2169 60 : COMPARE_NODE_FIELD(roles);
2170 60 : COMPARE_STRING_FIELD(new_tablespacename);
2171 60 : COMPARE_SCALAR_FIELD(nowait);
2172 :
2173 60 : return true;
2174 : }
2175 :
2176 : static bool
2177 1160 : _equalCreateExtensionStmt(const CreateExtensionStmt *a, const CreateExtensionStmt *b)
2178 : {
2179 1160 : COMPARE_STRING_FIELD(extname);
2180 1160 : COMPARE_SCALAR_FIELD(if_not_exists);
2181 1160 : COMPARE_NODE_FIELD(options);
2182 :
2183 1160 : return true;
2184 : }
2185 :
2186 : static bool
2187 74 : _equalAlterExtensionStmt(const AlterExtensionStmt *a, const AlterExtensionStmt *b)
2188 : {
2189 74 : COMPARE_STRING_FIELD(extname);
2190 74 : COMPARE_NODE_FIELD(options);
2191 :
2192 74 : return true;
2193 : }
2194 :
2195 : static bool
2196 508 : _equalAlterExtensionContentsStmt(const AlterExtensionContentsStmt *a, const AlterExtensionContentsStmt *b)
2197 : {
2198 508 : COMPARE_STRING_FIELD(extname);
2199 508 : COMPARE_SCALAR_FIELD(action);
2200 508 : COMPARE_SCALAR_FIELD(objtype);
2201 508 : COMPARE_NODE_FIELD(object);
2202 :
2203 508 : return true;
2204 : }
2205 :
2206 : static bool
2207 412 : _equalCreateFdwStmt(const CreateFdwStmt *a, const CreateFdwStmt *b)
2208 : {
2209 412 : COMPARE_STRING_FIELD(fdwname);
2210 412 : COMPARE_NODE_FIELD(func_options);
2211 412 : COMPARE_NODE_FIELD(options);
2212 :
2213 412 : return true;
2214 : }
2215 :
2216 : static bool
2217 244 : _equalAlterFdwStmt(const AlterFdwStmt *a, const AlterFdwStmt *b)
2218 : {
2219 244 : COMPARE_STRING_FIELD(fdwname);
2220 244 : COMPARE_NODE_FIELD(func_options);
2221 244 : COMPARE_NODE_FIELD(options);
2222 :
2223 244 : return true;
2224 : }
2225 :
2226 : static bool
2227 594 : _equalCreateForeignServerStmt(const CreateForeignServerStmt *a, const CreateForeignServerStmt *b)
2228 : {
2229 594 : COMPARE_STRING_FIELD(servername);
2230 594 : COMPARE_STRING_FIELD(servertype);
2231 594 : COMPARE_STRING_FIELD(version);
2232 594 : COMPARE_STRING_FIELD(fdwname);
2233 594 : COMPARE_SCALAR_FIELD(if_not_exists);
2234 594 : COMPARE_NODE_FIELD(options);
2235 :
2236 594 : return true;
2237 : }
2238 :
2239 : static bool
2240 464 : _equalAlterForeignServerStmt(const AlterForeignServerStmt *a, const AlterForeignServerStmt *b)
2241 : {
2242 464 : COMPARE_STRING_FIELD(servername);
2243 464 : COMPARE_STRING_FIELD(version);
2244 464 : COMPARE_NODE_FIELD(options);
2245 464 : COMPARE_SCALAR_FIELD(has_version);
2246 :
2247 464 : return true;
2248 : }
2249 :
2250 : static bool
2251 976 : _equalCreateForeignTableStmt(const CreateForeignTableStmt *a, const CreateForeignTableStmt *b)
2252 : {
2253 976 : COMPARE_NODE_FIELD(base.relation);
2254 976 : COMPARE_NODE_FIELD(base.tableElts);
2255 976 : COMPARE_NODE_FIELD(base.inhRelations);
2256 976 : COMPARE_NODE_FIELD(base.partbound);
2257 976 : COMPARE_NODE_FIELD(base.partspec);
2258 976 : COMPARE_NODE_FIELD(base.ofTypename);
2259 976 : COMPARE_NODE_FIELD(base.constraints);
2260 976 : COMPARE_NODE_FIELD(base.nnconstraints);
2261 976 : COMPARE_NODE_FIELD(base.options);
2262 976 : COMPARE_SCALAR_FIELD(base.oncommit);
2263 976 : COMPARE_STRING_FIELD(base.tablespacename);
2264 976 : COMPARE_STRING_FIELD(base.accessMethod);
2265 976 : COMPARE_SCALAR_FIELD(base.if_not_exists);
2266 976 : COMPARE_STRING_FIELD(servername);
2267 976 : COMPARE_NODE_FIELD(options);
2268 :
2269 976 : return true;
2270 : }
2271 :
2272 : static bool
2273 520 : _equalCreateUserMappingStmt(const CreateUserMappingStmt *a, const CreateUserMappingStmt *b)
2274 : {
2275 520 : COMPARE_NODE_FIELD(user);
2276 520 : COMPARE_STRING_FIELD(servername);
2277 520 : COMPARE_SCALAR_FIELD(if_not_exists);
2278 520 : COMPARE_NODE_FIELD(options);
2279 :
2280 520 : return true;
2281 : }
2282 :
2283 : static bool
2284 236 : _equalAlterUserMappingStmt(const AlterUserMappingStmt *a, const AlterUserMappingStmt *b)
2285 : {
2286 236 : COMPARE_NODE_FIELD(user);
2287 236 : COMPARE_STRING_FIELD(servername);
2288 236 : COMPARE_NODE_FIELD(options);
2289 :
2290 236 : return true;
2291 : }
2292 :
2293 : static bool
2294 252 : _equalDropUserMappingStmt(const DropUserMappingStmt *a, const DropUserMappingStmt *b)
2295 : {
2296 252 : COMPARE_NODE_FIELD(user);
2297 252 : COMPARE_STRING_FIELD(servername);
2298 252 : COMPARE_SCALAR_FIELD(missing_ok);
2299 :
2300 252 : return true;
2301 : }
2302 :
2303 : static bool
2304 96 : _equalImportForeignSchemaStmt(const ImportForeignSchemaStmt *a, const ImportForeignSchemaStmt *b)
2305 : {
2306 96 : COMPARE_STRING_FIELD(server_name);
2307 96 : COMPARE_STRING_FIELD(remote_schema);
2308 96 : COMPARE_STRING_FIELD(local_schema);
2309 96 : COMPARE_SCALAR_FIELD(list_type);
2310 96 : COMPARE_NODE_FIELD(table_list);
2311 96 : COMPARE_NODE_FIELD(options);
2312 :
2313 96 : return true;
2314 : }
2315 :
2316 : static bool
2317 1580 : _equalCreatePolicyStmt(const CreatePolicyStmt *a, const CreatePolicyStmt *b)
2318 : {
2319 1580 : COMPARE_STRING_FIELD(policy_name);
2320 1580 : COMPARE_NODE_FIELD(table);
2321 1580 : COMPARE_STRING_FIELD(cmd_name);
2322 1580 : COMPARE_SCALAR_FIELD(permissive);
2323 1580 : COMPARE_NODE_FIELD(roles);
2324 1580 : COMPARE_NODE_FIELD(qual);
2325 1580 : COMPARE_NODE_FIELD(with_check);
2326 :
2327 1580 : return true;
2328 : }
2329 :
2330 : static bool
2331 168 : _equalAlterPolicyStmt(const AlterPolicyStmt *a, const AlterPolicyStmt *b)
2332 : {
2333 168 : COMPARE_STRING_FIELD(policy_name);
2334 168 : COMPARE_NODE_FIELD(table);
2335 168 : COMPARE_NODE_FIELD(roles);
2336 168 : COMPARE_NODE_FIELD(qual);
2337 168 : COMPARE_NODE_FIELD(with_check);
2338 :
2339 168 : return true;
2340 : }
2341 :
2342 : static bool
2343 148 : _equalCreateAmStmt(const CreateAmStmt *a, const CreateAmStmt *b)
2344 : {
2345 148 : COMPARE_STRING_FIELD(amname);
2346 148 : COMPARE_NODE_FIELD(handler_name);
2347 148 : COMPARE_SCALAR_FIELD(amtype);
2348 :
2349 148 : return true;
2350 : }
2351 :
2352 : static bool
2353 6584 : _equalCreateTrigStmt(const CreateTrigStmt *a, const CreateTrigStmt *b)
2354 : {
2355 6584 : COMPARE_SCALAR_FIELD(replace);
2356 6584 : COMPARE_SCALAR_FIELD(isconstraint);
2357 6584 : COMPARE_STRING_FIELD(trigname);
2358 6584 : COMPARE_NODE_FIELD(relation);
2359 6584 : COMPARE_NODE_FIELD(funcname);
2360 6584 : COMPARE_NODE_FIELD(args);
2361 6584 : COMPARE_SCALAR_FIELD(row);
2362 6584 : COMPARE_SCALAR_FIELD(timing);
2363 6584 : COMPARE_SCALAR_FIELD(events);
2364 6584 : COMPARE_NODE_FIELD(columns);
2365 6584 : COMPARE_NODE_FIELD(whenClause);
2366 6584 : COMPARE_NODE_FIELD(transitionRels);
2367 6584 : COMPARE_SCALAR_FIELD(deferrable);
2368 6584 : COMPARE_SCALAR_FIELD(initdeferred);
2369 6584 : COMPARE_NODE_FIELD(constrrel);
2370 :
2371 6584 : return true;
2372 : }
2373 :
2374 : static bool
2375 400 : _equalCreateEventTrigStmt(const CreateEventTrigStmt *a, const CreateEventTrigStmt *b)
2376 : {
2377 400 : COMPARE_STRING_FIELD(trigname);
2378 400 : COMPARE_STRING_FIELD(eventname);
2379 400 : COMPARE_NODE_FIELD(whenclause);
2380 400 : COMPARE_NODE_FIELD(funcname);
2381 :
2382 400 : return true;
2383 : }
2384 :
2385 : static bool
2386 96 : _equalAlterEventTrigStmt(const AlterEventTrigStmt *a, const AlterEventTrigStmt *b)
2387 : {
2388 96 : COMPARE_STRING_FIELD(trigname);
2389 96 : COMPARE_SCALAR_FIELD(tgenabled);
2390 :
2391 96 : return true;
2392 : }
2393 :
2394 : static bool
2395 288 : _equalCreatePLangStmt(const CreatePLangStmt *a, const CreatePLangStmt *b)
2396 : {
2397 288 : COMPARE_SCALAR_FIELD(replace);
2398 288 : COMPARE_STRING_FIELD(plname);
2399 288 : COMPARE_NODE_FIELD(plhandler);
2400 288 : COMPARE_NODE_FIELD(plinline);
2401 288 : COMPARE_NODE_FIELD(plvalidator);
2402 288 : COMPARE_SCALAR_FIELD(pltrusted);
2403 :
2404 288 : return true;
2405 : }
2406 :
2407 : static bool
2408 3844 : _equalCreateRoleStmt(const CreateRoleStmt *a, const CreateRoleStmt *b)
2409 : {
2410 3844 : COMPARE_SCALAR_FIELD(stmt_type);
2411 3844 : COMPARE_STRING_FIELD(role);
2412 3844 : COMPARE_NODE_FIELD(options);
2413 :
2414 3844 : return true;
2415 : }
2416 :
2417 : static bool
2418 956 : _equalAlterRoleStmt(const AlterRoleStmt *a, const AlterRoleStmt *b)
2419 : {
2420 956 : COMPARE_NODE_FIELD(role);
2421 956 : COMPARE_NODE_FIELD(options);
2422 956 : COMPARE_SCALAR_FIELD(action);
2423 :
2424 956 : return true;
2425 : }
2426 :
2427 : static bool
2428 188 : _equalAlterRoleSetStmt(const AlterRoleSetStmt *a, const AlterRoleSetStmt *b)
2429 : {
2430 188 : COMPARE_NODE_FIELD(role);
2431 188 : COMPARE_STRING_FIELD(database);
2432 188 : COMPARE_NODE_FIELD(setstmt);
2433 :
2434 188 : return true;
2435 : }
2436 :
2437 : static bool
2438 3532 : _equalDropRoleStmt(const DropRoleStmt *a, const DropRoleStmt *b)
2439 : {
2440 3532 : COMPARE_NODE_FIELD(roles);
2441 3532 : COMPARE_SCALAR_FIELD(missing_ok);
2442 :
2443 3532 : return true;
2444 : }
2445 :
2446 : static bool
2447 1432 : _equalCreateSeqStmt(const CreateSeqStmt *a, const CreateSeqStmt *b)
2448 : {
2449 1432 : COMPARE_NODE_FIELD(sequence);
2450 1432 : COMPARE_NODE_FIELD(options);
2451 1432 : COMPARE_SCALAR_FIELD(ownerId);
2452 1432 : COMPARE_SCALAR_FIELD(for_identity);
2453 1432 : COMPARE_SCALAR_FIELD(if_not_exists);
2454 :
2455 1432 : return true;
2456 : }
2457 :
2458 : static bool
2459 400 : _equalAlterSeqStmt(const AlterSeqStmt *a, const AlterSeqStmt *b)
2460 : {
2461 400 : COMPARE_NODE_FIELD(sequence);
2462 400 : COMPARE_NODE_FIELD(options);
2463 400 : COMPARE_SCALAR_FIELD(for_identity);
2464 400 : COMPARE_SCALAR_FIELD(missing_ok);
2465 :
2466 400 : return true;
2467 : }
2468 :
2469 : static bool
2470 19576 : _equalDefineStmt(const DefineStmt *a, const DefineStmt *b)
2471 : {
2472 19576 : COMPARE_SCALAR_FIELD(kind);
2473 19576 : COMPARE_SCALAR_FIELD(oldstyle);
2474 19576 : COMPARE_NODE_FIELD(defnames);
2475 19576 : COMPARE_NODE_FIELD(args);
2476 19576 : COMPARE_NODE_FIELD(definition);
2477 19576 : COMPARE_SCALAR_FIELD(if_not_exists);
2478 19576 : COMPARE_SCALAR_FIELD(replace);
2479 :
2480 19576 : return true;
2481 : }
2482 :
2483 : static bool
2484 2948 : _equalCreateDomainStmt(const CreateDomainStmt *a, const CreateDomainStmt *b)
2485 : {
2486 2948 : COMPARE_NODE_FIELD(domainname);
2487 2948 : COMPARE_NODE_FIELD(typeName);
2488 2948 : COMPARE_NODE_FIELD(collClause);
2489 2948 : COMPARE_NODE_FIELD(constraints);
2490 :
2491 2948 : return true;
2492 : }
2493 :
2494 : static bool
2495 1112 : _equalCreateOpClassStmt(const CreateOpClassStmt *a, const CreateOpClassStmt *b)
2496 : {
2497 1112 : COMPARE_NODE_FIELD(opclassname);
2498 1112 : COMPARE_NODE_FIELD(opfamilyname);
2499 1112 : COMPARE_STRING_FIELD(amname);
2500 1112 : COMPARE_NODE_FIELD(datatype);
2501 1112 : COMPARE_NODE_FIELD(items);
2502 1112 : COMPARE_SCALAR_FIELD(isDefault);
2503 :
2504 1112 : return true;
2505 : }
2506 :
2507 : static bool
2508 13788 : _equalCreateOpClassItem(const CreateOpClassItem *a, const CreateOpClassItem *b)
2509 : {
2510 13788 : COMPARE_SCALAR_FIELD(itemtype);
2511 13788 : COMPARE_NODE_FIELD(name);
2512 13788 : COMPARE_SCALAR_FIELD(number);
2513 13788 : COMPARE_NODE_FIELD(order_family);
2514 13788 : COMPARE_NODE_FIELD(class_args);
2515 13788 : COMPARE_NODE_FIELD(storedtype);
2516 :
2517 13788 : return true;
2518 : }
2519 :
2520 : static bool
2521 296 : _equalCreateOpFamilyStmt(const CreateOpFamilyStmt *a, const CreateOpFamilyStmt *b)
2522 : {
2523 296 : COMPARE_NODE_FIELD(opfamilyname);
2524 296 : COMPARE_STRING_FIELD(amname);
2525 :
2526 296 : return true;
2527 : }
2528 :
2529 : static bool
2530 916 : _equalAlterOpFamilyStmt(const AlterOpFamilyStmt *a, const AlterOpFamilyStmt *b)
2531 : {
2532 916 : COMPARE_NODE_FIELD(opfamilyname);
2533 916 : COMPARE_STRING_FIELD(amname);
2534 916 : COMPARE_SCALAR_FIELD(isDrop);
2535 916 : COMPARE_NODE_FIELD(items);
2536 :
2537 916 : return true;
2538 : }
2539 :
2540 : static bool
2541 53814 : _equalDropStmt(const DropStmt *a, const DropStmt *b)
2542 : {
2543 53814 : COMPARE_NODE_FIELD(objects);
2544 53814 : COMPARE_SCALAR_FIELD(removeType);
2545 53814 : COMPARE_SCALAR_FIELD(behavior);
2546 53814 : COMPARE_SCALAR_FIELD(missing_ok);
2547 53814 : COMPARE_SCALAR_FIELD(concurrent);
2548 :
2549 53814 : return true;
2550 : }
2551 :
2552 : static bool
2553 3654 : _equalTruncateStmt(const TruncateStmt *a, const TruncateStmt *b)
2554 : {
2555 3654 : COMPARE_NODE_FIELD(relations);
2556 3654 : COMPARE_SCALAR_FIELD(restart_seqs);
2557 3654 : COMPARE_SCALAR_FIELD(behavior);
2558 :
2559 3654 : return true;
2560 : }
2561 :
2562 : static bool
2563 15260 : _equalCommentStmt(const CommentStmt *a, const CommentStmt *b)
2564 : {
2565 15260 : COMPARE_SCALAR_FIELD(objtype);
2566 15260 : COMPARE_NODE_FIELD(object);
2567 15260 : COMPARE_STRING_FIELD(comment);
2568 :
2569 15260 : return true;
2570 : }
2571 :
2572 : static bool
2573 236 : _equalSecLabelStmt(const SecLabelStmt *a, const SecLabelStmt *b)
2574 : {
2575 236 : COMPARE_SCALAR_FIELD(objtype);
2576 236 : COMPARE_NODE_FIELD(object);
2577 236 : COMPARE_STRING_FIELD(provider);
2578 236 : COMPARE_STRING_FIELD(label);
2579 :
2580 236 : return true;
2581 : }
2582 :
2583 : static bool
2584 7456 : _equalDeclareCursorStmt(const DeclareCursorStmt *a, const DeclareCursorStmt *b)
2585 : {
2586 7456 : COMPARE_STRING_FIELD(portalname);
2587 7456 : COMPARE_SCALAR_FIELD(options);
2588 7456 : COMPARE_NODE_FIELD(query);
2589 :
2590 7456 : return true;
2591 : }
2592 :
2593 : static bool
2594 4504 : _equalClosePortalStmt(const ClosePortalStmt *a, const ClosePortalStmt *b)
2595 : {
2596 4504 : COMPARE_STRING_FIELD(portalname);
2597 :
2598 4504 : return true;
2599 : }
2600 :
2601 : static bool
2602 13698 : _equalFetchStmt(const FetchStmt *a, const FetchStmt *b)
2603 : {
2604 13698 : COMPARE_SCALAR_FIELD(direction);
2605 13698 : COMPARE_SCALAR_FIELD(howMany);
2606 13698 : COMPARE_STRING_FIELD(portalname);
2607 13698 : COMPARE_SCALAR_FIELD(ismove);
2608 13698 : COMPARE_SCALAR_FIELD(direction_keyword);
2609 : COMPARE_LOCATION_FIELD(location);
2610 :
2611 13698 : return true;
2612 : }
2613 :
2614 : static bool
2615 13230 : _equalIndexStmt(const IndexStmt *a, const IndexStmt *b)
2616 : {
2617 13230 : COMPARE_STRING_FIELD(idxname);
2618 13230 : COMPARE_NODE_FIELD(relation);
2619 13230 : COMPARE_STRING_FIELD(accessMethod);
2620 13230 : COMPARE_STRING_FIELD(tableSpace);
2621 13230 : COMPARE_NODE_FIELD(indexParams);
2622 13230 : COMPARE_NODE_FIELD(indexIncludingParams);
2623 13230 : COMPARE_NODE_FIELD(options);
2624 13230 : COMPARE_NODE_FIELD(whereClause);
2625 13230 : COMPARE_NODE_FIELD(excludeOpNames);
2626 13230 : COMPARE_STRING_FIELD(idxcomment);
2627 13230 : COMPARE_SCALAR_FIELD(indexOid);
2628 13230 : COMPARE_SCALAR_FIELD(oldNumber);
2629 13230 : COMPARE_SCALAR_FIELD(oldCreateSubid);
2630 13230 : COMPARE_SCALAR_FIELD(oldFirstRelfilelocatorSubid);
2631 13230 : COMPARE_SCALAR_FIELD(unique);
2632 13230 : COMPARE_SCALAR_FIELD(nulls_not_distinct);
2633 13230 : COMPARE_SCALAR_FIELD(primary);
2634 13230 : COMPARE_SCALAR_FIELD(isconstraint);
2635 13230 : COMPARE_SCALAR_FIELD(iswithoutoverlaps);
2636 13230 : COMPARE_SCALAR_FIELD(deferrable);
2637 13230 : COMPARE_SCALAR_FIELD(initdeferred);
2638 13230 : COMPARE_SCALAR_FIELD(transformed);
2639 13230 : COMPARE_SCALAR_FIELD(concurrent);
2640 13230 : COMPARE_SCALAR_FIELD(if_not_exists);
2641 13230 : COMPARE_SCALAR_FIELD(reset_default_tblspc);
2642 :
2643 13230 : return true;
2644 : }
2645 :
2646 : static bool
2647 1730 : _equalCreateStatsStmt(const CreateStatsStmt *a, const CreateStatsStmt *b)
2648 : {
2649 1730 : COMPARE_NODE_FIELD(defnames);
2650 1730 : COMPARE_NODE_FIELD(stat_types);
2651 1730 : COMPARE_NODE_FIELD(exprs);
2652 1730 : COMPARE_NODE_FIELD(relations);
2653 1730 : COMPARE_STRING_FIELD(stxcomment);
2654 1730 : COMPARE_SCALAR_FIELD(transformed);
2655 1730 : COMPARE_SCALAR_FIELD(if_not_exists);
2656 :
2657 1730 : return true;
2658 : }
2659 :
2660 : static bool
2661 4052 : _equalStatsElem(const StatsElem *a, const StatsElem *b)
2662 : {
2663 4052 : COMPARE_STRING_FIELD(name);
2664 4052 : COMPARE_NODE_FIELD(expr);
2665 :
2666 4052 : return true;
2667 : }
2668 :
2669 : static bool
2670 52 : _equalAlterStatsStmt(const AlterStatsStmt *a, const AlterStatsStmt *b)
2671 : {
2672 52 : COMPARE_NODE_FIELD(defnames);
2673 52 : COMPARE_NODE_FIELD(stxstattarget);
2674 52 : COMPARE_SCALAR_FIELD(missing_ok);
2675 :
2676 52 : return true;
2677 : }
2678 :
2679 : static bool
2680 52152 : _equalCreateFunctionStmt(const CreateFunctionStmt *a, const CreateFunctionStmt *b)
2681 : {
2682 52152 : COMPARE_SCALAR_FIELD(is_procedure);
2683 52152 : COMPARE_SCALAR_FIELD(replace);
2684 52152 : COMPARE_NODE_FIELD(funcname);
2685 52152 : COMPARE_NODE_FIELD(parameters);
2686 52152 : COMPARE_NODE_FIELD(returnType);
2687 52152 : COMPARE_NODE_FIELD(options);
2688 52152 : COMPARE_NODE_FIELD(sql_body);
2689 :
2690 52152 : return true;
2691 : }
2692 :
2693 : static bool
2694 160950 : _equalFunctionParameter(const FunctionParameter *a, const FunctionParameter *b)
2695 : {
2696 160950 : COMPARE_STRING_FIELD(name);
2697 160950 : COMPARE_NODE_FIELD(argType);
2698 160950 : COMPARE_SCALAR_FIELD(mode);
2699 160950 : COMPARE_NODE_FIELD(defexpr);
2700 : COMPARE_LOCATION_FIELD(location);
2701 :
2702 160950 : return true;
2703 : }
2704 :
2705 : static bool
2706 716 : _equalAlterFunctionStmt(const AlterFunctionStmt *a, const AlterFunctionStmt *b)
2707 : {
2708 716 : COMPARE_SCALAR_FIELD(objtype);
2709 716 : COMPARE_NODE_FIELD(func);
2710 716 : COMPARE_NODE_FIELD(actions);
2711 :
2712 716 : return true;
2713 : }
2714 :
2715 : static bool
2716 2248 : _equalDoStmt(const DoStmt *a, const DoStmt *b)
2717 : {
2718 2248 : COMPARE_NODE_FIELD(args);
2719 :
2720 2248 : return true;
2721 : }
2722 :
2723 : static bool
2724 914 : _equalCallStmt(const CallStmt *a, const CallStmt *b)
2725 : {
2726 914 : COMPARE_NODE_FIELD(funccall);
2727 914 : COMPARE_NODE_FIELD(funcexpr);
2728 914 : COMPARE_NODE_FIELD(outargs);
2729 :
2730 914 : return true;
2731 : }
2732 :
2733 : static bool
2734 2868 : _equalRenameStmt(const RenameStmt *a, const RenameStmt *b)
2735 : {
2736 2868 : COMPARE_SCALAR_FIELD(renameType);
2737 2868 : COMPARE_SCALAR_FIELD(relationType);
2738 2868 : COMPARE_NODE_FIELD(relation);
2739 2868 : COMPARE_NODE_FIELD(object);
2740 2868 : COMPARE_STRING_FIELD(subname);
2741 2868 : COMPARE_STRING_FIELD(newname);
2742 2868 : COMPARE_SCALAR_FIELD(behavior);
2743 2868 : COMPARE_SCALAR_FIELD(missing_ok);
2744 :
2745 2868 : return true;
2746 : }
2747 :
2748 : static bool
2749 92 : _equalAlterObjectDependsStmt(const AlterObjectDependsStmt *a, const AlterObjectDependsStmt *b)
2750 : {
2751 92 : COMPARE_SCALAR_FIELD(objectType);
2752 92 : COMPARE_NODE_FIELD(relation);
2753 92 : COMPARE_NODE_FIELD(object);
2754 92 : COMPARE_NODE_FIELD(extname);
2755 92 : COMPARE_SCALAR_FIELD(remove);
2756 :
2757 92 : return true;
2758 : }
2759 :
2760 : static bool
2761 796 : _equalAlterObjectSchemaStmt(const AlterObjectSchemaStmt *a, const AlterObjectSchemaStmt *b)
2762 : {
2763 796 : COMPARE_SCALAR_FIELD(objectType);
2764 796 : COMPARE_NODE_FIELD(relation);
2765 796 : COMPARE_NODE_FIELD(object);
2766 796 : COMPARE_STRING_FIELD(newschema);
2767 796 : COMPARE_SCALAR_FIELD(missing_ok);
2768 :
2769 796 : return true;
2770 : }
2771 :
2772 : static bool
2773 3358 : _equalAlterOwnerStmt(const AlterOwnerStmt *a, const AlterOwnerStmt *b)
2774 : {
2775 3358 : COMPARE_SCALAR_FIELD(objectType);
2776 3358 : COMPARE_NODE_FIELD(relation);
2777 3358 : COMPARE_NODE_FIELD(object);
2778 3358 : COMPARE_NODE_FIELD(newowner);
2779 :
2780 3358 : return true;
2781 : }
2782 :
2783 : static bool
2784 1216 : _equalAlterOperatorStmt(const AlterOperatorStmt *a, const AlterOperatorStmt *b)
2785 : {
2786 1216 : COMPARE_NODE_FIELD(opername);
2787 1216 : COMPARE_NODE_FIELD(options);
2788 :
2789 1216 : return true;
2790 : }
2791 :
2792 : static bool
2793 120 : _equalAlterTypeStmt(const AlterTypeStmt *a, const AlterTypeStmt *b)
2794 : {
2795 120 : COMPARE_NODE_FIELD(typeName);
2796 120 : COMPARE_NODE_FIELD(options);
2797 :
2798 120 : return true;
2799 : }
2800 :
2801 : static bool
2802 2216 : _equalRuleStmt(const RuleStmt *a, const RuleStmt *b)
2803 : {
2804 2216 : COMPARE_NODE_FIELD(relation);
2805 2216 : COMPARE_STRING_FIELD(rulename);
2806 2216 : COMPARE_NODE_FIELD(whereClause);
2807 2216 : COMPARE_SCALAR_FIELD(event);
2808 2216 : COMPARE_SCALAR_FIELD(instead);
2809 2216 : COMPARE_NODE_FIELD(actions);
2810 2216 : COMPARE_SCALAR_FIELD(replace);
2811 :
2812 2216 : return true;
2813 : }
2814 :
2815 : static bool
2816 337 : _equalNotifyStmt(const NotifyStmt *a, const NotifyStmt *b)
2817 : {
2818 337 : COMPARE_STRING_FIELD(conditionname);
2819 337 : COMPARE_STRING_FIELD(payload);
2820 :
2821 337 : return true;
2822 : }
2823 :
2824 : static bool
2825 232 : _equalListenStmt(const ListenStmt *a, const ListenStmt *b)
2826 : {
2827 232 : COMPARE_STRING_FIELD(conditionname);
2828 :
2829 232 : return true;
2830 : }
2831 :
2832 : static bool
2833 312 : _equalUnlistenStmt(const UnlistenStmt *a, const UnlistenStmt *b)
2834 : {
2835 312 : COMPARE_STRING_FIELD(conditionname);
2836 :
2837 312 : return true;
2838 : }
2839 :
2840 : static bool
2841 97578 : _equalTransactionStmt(const TransactionStmt *a, const TransactionStmt *b)
2842 : {
2843 97578 : COMPARE_SCALAR_FIELD(kind);
2844 97578 : COMPARE_NODE_FIELD(options);
2845 97578 : COMPARE_STRING_FIELD(savepoint_name);
2846 97578 : COMPARE_STRING_FIELD(gid);
2847 97578 : COMPARE_SCALAR_FIELD(chain);
2848 : COMPARE_LOCATION_FIELD(location);
2849 :
2850 97578 : return true;
2851 : }
2852 :
2853 : static bool
2854 5236 : _equalCompositeTypeStmt(const CompositeTypeStmt *a, const CompositeTypeStmt *b)
2855 : {
2856 5236 : COMPARE_NODE_FIELD(typevar);
2857 5236 : COMPARE_NODE_FIELD(coldeflist);
2858 :
2859 5236 : return true;
2860 : }
2861 :
2862 : static bool
2863 412 : _equalCreateEnumStmt(const CreateEnumStmt *a, const CreateEnumStmt *b)
2864 : {
2865 412 : COMPARE_NODE_FIELD(typeName);
2866 412 : COMPARE_NODE_FIELD(vals);
2867 :
2868 412 : return true;
2869 : }
2870 :
2871 : static bool
2872 368 : _equalCreateRangeStmt(const CreateRangeStmt *a, const CreateRangeStmt *b)
2873 : {
2874 368 : COMPARE_NODE_FIELD(typeName);
2875 368 : COMPARE_NODE_FIELD(params);
2876 :
2877 368 : return true;
2878 : }
2879 :
2880 : static bool
2881 792 : _equalAlterEnumStmt(const AlterEnumStmt *a, const AlterEnumStmt *b)
2882 : {
2883 792 : COMPARE_NODE_FIELD(typeName);
2884 792 : COMPARE_STRING_FIELD(oldVal);
2885 792 : COMPARE_STRING_FIELD(newVal);
2886 792 : COMPARE_STRING_FIELD(newValNeighbor);
2887 792 : COMPARE_SCALAR_FIELD(newValIsAfter);
2888 792 : COMPARE_SCALAR_FIELD(skipIfNewValExists);
2889 :
2890 792 : return true;
2891 : }
2892 :
2893 : static bool
2894 34716 : _equalViewStmt(const ViewStmt *a, const ViewStmt *b)
2895 : {
2896 34716 : COMPARE_NODE_FIELD(view);
2897 34716 : COMPARE_NODE_FIELD(aliases);
2898 34716 : COMPARE_NODE_FIELD(query);
2899 34716 : COMPARE_SCALAR_FIELD(replace);
2900 34716 : COMPARE_NODE_FIELD(options);
2901 34716 : COMPARE_SCALAR_FIELD(withCheckOption);
2902 :
2903 34716 : return true;
2904 : }
2905 :
2906 : static bool
2907 128 : _equalLoadStmt(const LoadStmt *a, const LoadStmt *b)
2908 : {
2909 128 : COMPARE_STRING_FIELD(filename);
2910 :
2911 128 : return true;
2912 : }
2913 :
2914 : static bool
2915 1640 : _equalCreatedbStmt(const CreatedbStmt *a, const CreatedbStmt *b)
2916 : {
2917 1640 : COMPARE_STRING_FIELD(dbname);
2918 1640 : COMPARE_NODE_FIELD(options);
2919 :
2920 1640 : return true;
2921 : }
2922 :
2923 : static bool
2924 184 : _equalAlterDatabaseStmt(const AlterDatabaseStmt *a, const AlterDatabaseStmt *b)
2925 : {
2926 184 : COMPARE_STRING_FIELD(dbname);
2927 184 : COMPARE_NODE_FIELD(options);
2928 :
2929 184 : return true;
2930 : }
2931 :
2932 : static bool
2933 12 : _equalAlterDatabaseRefreshCollStmt(const AlterDatabaseRefreshCollStmt *a, const AlterDatabaseRefreshCollStmt *b)
2934 : {
2935 12 : COMPARE_STRING_FIELD(dbname);
2936 :
2937 12 : return true;
2938 : }
2939 :
2940 : static bool
2941 2520 : _equalAlterDatabaseSetStmt(const AlterDatabaseSetStmt *a, const AlterDatabaseSetStmt *b)
2942 : {
2943 2520 : COMPARE_STRING_FIELD(dbname);
2944 2520 : COMPARE_NODE_FIELD(setstmt);
2945 :
2946 2520 : return true;
2947 : }
2948 :
2949 : static bool
2950 256 : _equalDropdbStmt(const DropdbStmt *a, const DropdbStmt *b)
2951 : {
2952 256 : COMPARE_STRING_FIELD(dbname);
2953 256 : COMPARE_SCALAR_FIELD(missing_ok);
2954 256 : COMPARE_NODE_FIELD(options);
2955 :
2956 256 : return true;
2957 : }
2958 :
2959 : static bool
2960 420 : _equalAlterSystemStmt(const AlterSystemStmt *a, const AlterSystemStmt *b)
2961 : {
2962 420 : COMPARE_NODE_FIELD(setstmt);
2963 :
2964 420 : return true;
2965 : }
2966 :
2967 : static bool
2968 476 : _equalClusterStmt(const ClusterStmt *a, const ClusterStmt *b)
2969 : {
2970 476 : COMPARE_NODE_FIELD(relation);
2971 476 : COMPARE_STRING_FIELD(indexname);
2972 476 : COMPARE_NODE_FIELD(params);
2973 :
2974 476 : return true;
2975 : }
2976 :
2977 : static bool
2978 29462 : _equalVacuumStmt(const VacuumStmt *a, const VacuumStmt *b)
2979 : {
2980 29462 : COMPARE_NODE_FIELD(options);
2981 29462 : COMPARE_NODE_FIELD(rels);
2982 29462 : COMPARE_SCALAR_FIELD(is_vacuumcmd);
2983 :
2984 29462 : return true;
2985 : }
2986 :
2987 : static bool
2988 29106 : _equalVacuumRelation(const VacuumRelation *a, const VacuumRelation *b)
2989 : {
2990 29106 : COMPARE_NODE_FIELD(relation);
2991 29106 : COMPARE_SCALAR_FIELD(oid);
2992 29106 : COMPARE_NODE_FIELD(va_cols);
2993 :
2994 29106 : return true;
2995 : }
2996 :
2997 : static bool
2998 41730 : _equalExplainStmt(const ExplainStmt *a, const ExplainStmt *b)
2999 : {
3000 41730 : COMPARE_NODE_FIELD(query);
3001 41730 : COMPARE_NODE_FIELD(options);
3002 :
3003 41730 : return true;
3004 : }
3005 :
3006 : static bool
3007 3884 : _equalCreateTableAsStmt(const CreateTableAsStmt *a, const CreateTableAsStmt *b)
3008 : {
3009 3884 : COMPARE_NODE_FIELD(query);
3010 3884 : COMPARE_NODE_FIELD(into);
3011 3884 : COMPARE_SCALAR_FIELD(objtype);
3012 3884 : COMPARE_SCALAR_FIELD(is_select_into);
3013 3884 : COMPARE_SCALAR_FIELD(if_not_exists);
3014 :
3015 3884 : return true;
3016 : }
3017 :
3018 : static bool
3019 536 : _equalRefreshMatViewStmt(const RefreshMatViewStmt *a, const RefreshMatViewStmt *b)
3020 : {
3021 536 : COMPARE_SCALAR_FIELD(concurrent);
3022 536 : COMPARE_SCALAR_FIELD(skipData);
3023 536 : COMPARE_NODE_FIELD(relation);
3024 :
3025 536 : return true;
3026 : }
3027 :
3028 : static bool
3029 510 : _equalCheckPointStmt(const CheckPointStmt *a, const CheckPointStmt *b)
3030 : {
3031 510 : COMPARE_NODE_FIELD(options);
3032 :
3033 510 : return true;
3034 : }
3035 :
3036 : static bool
3037 76 : _equalDiscardStmt(const DiscardStmt *a, const DiscardStmt *b)
3038 : {
3039 76 : COMPARE_SCALAR_FIELD(target);
3040 :
3041 76 : return true;
3042 : }
3043 :
3044 : static bool
3045 2104 : _equalLockStmt(const LockStmt *a, const LockStmt *b)
3046 : {
3047 2104 : COMPARE_NODE_FIELD(relations);
3048 2104 : COMPARE_SCALAR_FIELD(mode);
3049 2104 : COMPARE_SCALAR_FIELD(nowait);
3050 :
3051 2104 : return true;
3052 : }
3053 :
3054 : static bool
3055 202 : _equalConstraintsSetStmt(const ConstraintsSetStmt *a, const ConstraintsSetStmt *b)
3056 : {
3057 202 : COMPARE_NODE_FIELD(constraints);
3058 202 : COMPARE_SCALAR_FIELD(deferred);
3059 :
3060 202 : return true;
3061 : }
3062 :
3063 : static bool
3064 2264 : _equalReindexStmt(const ReindexStmt *a, const ReindexStmt *b)
3065 : {
3066 2264 : COMPARE_SCALAR_FIELD(kind);
3067 2264 : COMPARE_NODE_FIELD(relation);
3068 2264 : COMPARE_STRING_FIELD(name);
3069 2264 : COMPARE_NODE_FIELD(params);
3070 :
3071 2264 : return true;
3072 : }
3073 :
3074 : static bool
3075 128 : _equalCreateConversionStmt(const CreateConversionStmt *a, const CreateConversionStmt *b)
3076 : {
3077 128 : COMPARE_NODE_FIELD(conversion_name);
3078 128 : COMPARE_STRING_FIELD(for_encoding_name);
3079 128 : COMPARE_STRING_FIELD(to_encoding_name);
3080 128 : COMPARE_NODE_FIELD(func_name);
3081 128 : COMPARE_SCALAR_FIELD(def);
3082 :
3083 128 : return true;
3084 : }
3085 :
3086 : static bool
3087 556 : _equalCreateCastStmt(const CreateCastStmt *a, const CreateCastStmt *b)
3088 : {
3089 556 : COMPARE_NODE_FIELD(sourcetype);
3090 556 : COMPARE_NODE_FIELD(targettype);
3091 556 : COMPARE_NODE_FIELD(func);
3092 556 : COMPARE_SCALAR_FIELD(context);
3093 556 : COMPARE_SCALAR_FIELD(inout);
3094 :
3095 556 : return true;
3096 : }
3097 :
3098 : static bool
3099 100 : _equalCreateTransformStmt(const CreateTransformStmt *a, const CreateTransformStmt *b)
3100 : {
3101 100 : COMPARE_SCALAR_FIELD(replace);
3102 100 : COMPARE_NODE_FIELD(type_name);
3103 100 : COMPARE_STRING_FIELD(lang);
3104 100 : COMPARE_NODE_FIELD(fromsql);
3105 100 : COMPARE_NODE_FIELD(tosql);
3106 :
3107 100 : return true;
3108 : }
3109 :
3110 : static bool
3111 4028 : _equalPrepareStmt(const PrepareStmt *a, const PrepareStmt *b)
3112 : {
3113 4028 : COMPARE_STRING_FIELD(name);
3114 4028 : COMPARE_NODE_FIELD(argtypes);
3115 4028 : COMPARE_NODE_FIELD(query);
3116 :
3117 4028 : return true;
3118 : }
3119 :
3120 : static bool
3121 33262 : _equalExecuteStmt(const ExecuteStmt *a, const ExecuteStmt *b)
3122 : {
3123 33262 : COMPARE_STRING_FIELD(name);
3124 33262 : COMPARE_NODE_FIELD(params);
3125 :
3126 33262 : return true;
3127 : }
3128 :
3129 : static bool
3130 8204 : _equalDeallocateStmt(const DeallocateStmt *a, const DeallocateStmt *b)
3131 : {
3132 8204 : COMPARE_STRING_FIELD(name);
3133 8204 : COMPARE_SCALAR_FIELD(isall);
3134 : COMPARE_LOCATION_FIELD(location);
3135 :
3136 8204 : return true;
3137 : }
3138 :
3139 : static bool
3140 296 : _equalDropOwnedStmt(const DropOwnedStmt *a, const DropOwnedStmt *b)
3141 : {
3142 296 : COMPARE_NODE_FIELD(roles);
3143 296 : COMPARE_SCALAR_FIELD(behavior);
3144 :
3145 296 : return true;
3146 : }
3147 :
3148 : static bool
3149 92 : _equalReassignOwnedStmt(const ReassignOwnedStmt *a, const ReassignOwnedStmt *b)
3150 : {
3151 92 : COMPARE_NODE_FIELD(roles);
3152 92 : COMPARE_NODE_FIELD(newrole);
3153 :
3154 92 : return true;
3155 : }
3156 :
3157 : static bool
3158 80 : _equalAlterTSDictionaryStmt(const AlterTSDictionaryStmt *a, const AlterTSDictionaryStmt *b)
3159 : {
3160 80 : COMPARE_NODE_FIELD(dictname);
3161 80 : COMPARE_NODE_FIELD(options);
3162 :
3163 80 : return true;
3164 : }
3165 :
3166 : static bool
3167 18708 : _equalAlterTSConfigurationStmt(const AlterTSConfigurationStmt *a, const AlterTSConfigurationStmt *b)
3168 : {
3169 18708 : COMPARE_SCALAR_FIELD(kind);
3170 18708 : COMPARE_NODE_FIELD(cfgname);
3171 18708 : COMPARE_NODE_FIELD(tokentype);
3172 18708 : COMPARE_NODE_FIELD(dicts);
3173 18708 : COMPARE_SCALAR_FIELD(override);
3174 18708 : COMPARE_SCALAR_FIELD(replace);
3175 18708 : COMPARE_SCALAR_FIELD(missing_ok);
3176 :
3177 18708 : return true;
3178 : }
3179 :
3180 : static bool
3181 2876 : _equalPublicationTable(const PublicationTable *a, const PublicationTable *b)
3182 : {
3183 2876 : COMPARE_NODE_FIELD(relation);
3184 2876 : COMPARE_NODE_FIELD(whereClause);
3185 2876 : COMPARE_NODE_FIELD(columns);
3186 :
3187 2876 : return true;
3188 : }
3189 :
3190 : static bool
3191 3668 : _equalPublicationObjSpec(const PublicationObjSpec *a, const PublicationObjSpec *b)
3192 : {
3193 3668 : COMPARE_SCALAR_FIELD(pubobjtype);
3194 3668 : COMPARE_STRING_FIELD(name);
3195 3668 : COMPARE_NODE_FIELD(pubtable);
3196 : COMPARE_LOCATION_FIELD(location);
3197 :
3198 3668 : return true;
3199 : }
3200 :
3201 : static bool
3202 0 : _equalPublicationAllObjSpec(const PublicationAllObjSpec *a, const PublicationAllObjSpec *b)
3203 : {
3204 0 : COMPARE_SCALAR_FIELD(pubobjtype);
3205 : COMPARE_LOCATION_FIELD(location);
3206 :
3207 0 : return true;
3208 : }
3209 :
3210 : static bool
3211 1792 : _equalCreatePublicationStmt(const CreatePublicationStmt *a, const CreatePublicationStmt *b)
3212 : {
3213 1792 : COMPARE_STRING_FIELD(pubname);
3214 1792 : COMPARE_NODE_FIELD(options);
3215 1792 : COMPARE_NODE_FIELD(pubobjects);
3216 1792 : COMPARE_SCALAR_FIELD(for_all_tables);
3217 1792 : COMPARE_SCALAR_FIELD(for_all_sequences);
3218 :
3219 1792 : return true;
3220 : }
3221 :
3222 : static bool
3223 2212 : _equalAlterPublicationStmt(const AlterPublicationStmt *a, const AlterPublicationStmt *b)
3224 : {
3225 2212 : COMPARE_STRING_FIELD(pubname);
3226 2212 : COMPARE_NODE_FIELD(options);
3227 2212 : COMPARE_NODE_FIELD(pubobjects);
3228 2212 : COMPARE_SCALAR_FIELD(action);
3229 :
3230 2212 : return true;
3231 : }
3232 :
3233 : static bool
3234 968 : _equalCreateSubscriptionStmt(const CreateSubscriptionStmt *a, const CreateSubscriptionStmt *b)
3235 : {
3236 968 : COMPARE_STRING_FIELD(subname);
3237 968 : COMPARE_STRING_FIELD(conninfo);
3238 968 : COMPARE_NODE_FIELD(publication);
3239 968 : COMPARE_NODE_FIELD(options);
3240 :
3241 968 : return true;
3242 : }
3243 :
3244 : static bool
3245 1078 : _equalAlterSubscriptionStmt(const AlterSubscriptionStmt *a, const AlterSubscriptionStmt *b)
3246 : {
3247 1078 : COMPARE_SCALAR_FIELD(kind);
3248 1078 : COMPARE_STRING_FIELD(subname);
3249 1078 : COMPARE_STRING_FIELD(conninfo);
3250 1078 : COMPARE_NODE_FIELD(publication);
3251 1078 : COMPARE_NODE_FIELD(options);
3252 :
3253 1078 : return true;
3254 : }
3255 :
3256 : static bool
3257 500 : _equalDropSubscriptionStmt(const DropSubscriptionStmt *a, const DropSubscriptionStmt *b)
3258 : {
3259 500 : COMPARE_STRING_FIELD(subname);
3260 500 : COMPARE_SCALAR_FIELD(missing_ok);
3261 500 : COMPARE_SCALAR_FIELD(behavior);
3262 :
3263 500 : return true;
3264 : }
3265 :
3266 : static bool
3267 218 : _equalWaitStmt(const WaitStmt *a, const WaitStmt *b)
3268 : {
3269 218 : COMPARE_STRING_FIELD(lsn_literal);
3270 218 : COMPARE_NODE_FIELD(options);
3271 :
3272 218 : return true;
3273 : }
3274 :
3275 : static bool
3276 0 : _equalPathKey(const PathKey *a, const PathKey *b)
3277 : {
3278 0 : COMPARE_SCALAR_FIELD(pk_eclass);
3279 0 : COMPARE_SCALAR_FIELD(pk_opfamily);
3280 0 : COMPARE_SCALAR_FIELD(pk_cmptype);
3281 0 : COMPARE_SCALAR_FIELD(pk_nulls_first);
3282 :
3283 0 : return true;
3284 : }
3285 :
3286 : static bool
3287 0 : _equalGroupByOrdering(const GroupByOrdering *a, const GroupByOrdering *b)
3288 : {
3289 0 : COMPARE_NODE_FIELD(pathkeys);
3290 0 : COMPARE_NODE_FIELD(clauses);
3291 :
3292 0 : return true;
3293 : }
3294 :
3295 : static bool
3296 418 : _equalRestrictInfo(const RestrictInfo *a, const RestrictInfo *b)
3297 : {
3298 418 : COMPARE_NODE_FIELD(clause);
3299 80 : COMPARE_SCALAR_FIELD(is_pushed_down);
3300 80 : COMPARE_SCALAR_FIELD(has_clone);
3301 80 : COMPARE_SCALAR_FIELD(is_clone);
3302 80 : COMPARE_SCALAR_FIELD(security_level);
3303 80 : COMPARE_BITMAPSET_FIELD(required_relids);
3304 74 : COMPARE_BITMAPSET_FIELD(incompatible_relids);
3305 74 : COMPARE_BITMAPSET_FIELD(outer_relids);
3306 74 : COMPARE_SCALAR_FIELD(rinfo_serial);
3307 :
3308 74 : return true;
3309 : }
3310 :
3311 : static bool
3312 3506 : _equalPlaceHolderVar(const PlaceHolderVar *a, const PlaceHolderVar *b)
3313 : {
3314 3506 : COMPARE_BITMAPSET_FIELD(phnullingrels);
3315 3059 : COMPARE_SCALAR_FIELD(phid);
3316 2240 : COMPARE_SCALAR_FIELD(phlevelsup);
3317 :
3318 2240 : return true;
3319 : }
3320 :
3321 : static bool
3322 0 : _equalSpecialJoinInfo(const SpecialJoinInfo *a, const SpecialJoinInfo *b)
3323 : {
3324 0 : COMPARE_BITMAPSET_FIELD(min_lefthand);
3325 0 : COMPARE_BITMAPSET_FIELD(min_righthand);
3326 0 : COMPARE_BITMAPSET_FIELD(syn_lefthand);
3327 0 : COMPARE_BITMAPSET_FIELD(syn_righthand);
3328 0 : COMPARE_SCALAR_FIELD(jointype);
3329 0 : COMPARE_SCALAR_FIELD(ojrelid);
3330 0 : COMPARE_BITMAPSET_FIELD(commute_above_l);
3331 0 : COMPARE_BITMAPSET_FIELD(commute_above_r);
3332 0 : COMPARE_BITMAPSET_FIELD(commute_below_l);
3333 0 : COMPARE_BITMAPSET_FIELD(commute_below_r);
3334 0 : COMPARE_SCALAR_FIELD(lhs_strict);
3335 0 : COMPARE_SCALAR_FIELD(semi_can_btree);
3336 0 : COMPARE_SCALAR_FIELD(semi_can_hash);
3337 0 : COMPARE_NODE_FIELD(semi_operators);
3338 0 : COMPARE_NODE_FIELD(semi_rhs_exprs);
3339 :
3340 0 : return true;
3341 : }
3342 :
3343 : static bool
3344 0 : _equalAppendRelInfo(const AppendRelInfo *a, const AppendRelInfo *b)
3345 : {
3346 0 : COMPARE_SCALAR_FIELD(parent_relid);
3347 0 : COMPARE_SCALAR_FIELD(child_relid);
3348 0 : COMPARE_SCALAR_FIELD(parent_reltype);
3349 0 : COMPARE_SCALAR_FIELD(child_reltype);
3350 0 : COMPARE_NODE_FIELD(translated_vars);
3351 0 : COMPARE_SCALAR_FIELD(num_child_cols);
3352 0 : COMPARE_POINTER_FIELD(parent_colnos, a->num_child_cols * sizeof(AttrNumber));
3353 0 : COMPARE_SCALAR_FIELD(parent_reloid);
3354 :
3355 0 : return true;
3356 : }
3357 :
3358 : static bool
3359 0 : _equalPlaceHolderInfo(const PlaceHolderInfo *a, const PlaceHolderInfo *b)
3360 : {
3361 0 : COMPARE_SCALAR_FIELD(phid);
3362 0 : COMPARE_NODE_FIELD(ph_var);
3363 0 : COMPARE_BITMAPSET_FIELD(ph_eval_at);
3364 0 : COMPARE_BITMAPSET_FIELD(ph_lateral);
3365 0 : COMPARE_BITMAPSET_FIELD(ph_needed);
3366 0 : COMPARE_SCALAR_FIELD(ph_width);
3367 :
3368 0 : return true;
3369 : }
3370 :
3371 : static bool
3372 96 : _equalAggClauseInfo(const AggClauseInfo *a, const AggClauseInfo *b)
3373 : {
3374 96 : COMPARE_NODE_FIELD(aggref);
3375 3 : COMPARE_BITMAPSET_FIELD(agg_eval_at);
3376 :
3377 3 : return true;
3378 : }
3379 :
3380 : static bool
3381 0 : _equalGroupingExprInfo(const GroupingExprInfo *a, const GroupingExprInfo *b)
3382 : {
3383 0 : COMPARE_NODE_FIELD(expr);
3384 0 : COMPARE_SCALAR_FIELD(sortgroupref);
3385 0 : COMPARE_SCALAR_FIELD(ec);
3386 :
3387 0 : return true;
3388 : }
3389 :
3390 : static bool
3391 0 : _equalSubPlanRTInfo(const SubPlanRTInfo *a, const SubPlanRTInfo *b)
3392 : {
3393 0 : COMPARE_STRING_FIELD(plan_name);
3394 0 : COMPARE_SCALAR_FIELD(rtoffset);
3395 0 : COMPARE_SCALAR_FIELD(dummy);
3396 :
3397 0 : return true;
3398 : }
3399 :
3400 : static bool
3401 0 : _equalElidedNode(const ElidedNode *a, const ElidedNode *b)
3402 : {
3403 0 : COMPARE_SCALAR_FIELD(plan_node_id);
3404 0 : COMPARE_SCALAR_FIELD(elided_type);
3405 0 : COMPARE_BITMAPSET_FIELD(relids);
3406 :
3407 0 : return true;
3408 : }
3409 :
3410 : static bool
3411 497486 : _equalInteger(const Integer *a, const Integer *b)
3412 : {
3413 497486 : COMPARE_SCALAR_FIELD(ival);
3414 :
3415 497486 : return true;
3416 : }
3417 :
3418 : static bool
3419 12362 : _equalFloat(const Float *a, const Float *b)
3420 : {
3421 12362 : COMPARE_STRING_FIELD(fval);
3422 :
3423 12362 : return true;
3424 : }
3425 :
3426 : static bool
3427 107638 : _equalBoolean(const Boolean *a, const Boolean *b)
3428 : {
3429 107638 : COMPARE_SCALAR_FIELD(boolval);
3430 :
3431 107638 : return true;
3432 : }
3433 :
3434 : static bool
3435 17584460 : _equalString(const String *a, const String *b)
3436 : {
3437 17584460 : COMPARE_STRING_FIELD(sval);
3438 :
3439 17166403 : return true;
3440 : }
3441 :
3442 : static bool
3443 4070 : _equalBitString(const BitString *a, const BitString *b)
3444 : {
3445 4070 : COMPARE_STRING_FIELD(bsval);
3446 :
3447 4070 : return true;
3448 : }
|
