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