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