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