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