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