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