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