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