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