1 /*-------------------------------------------------------------------------
2 *
3 * equalfuncs.c
4 * Equality functions to compare node trees.
5 *
6 * NOTE: we currently support comparing all node types found in parse
7 * trees. We do not support comparing executor state trees; there
8 * is no need for that, and no point in maintaining all the code that
9 * would be needed. We also do not support comparing Path trees, mainly
10 * because the circular linkages between RelOptInfo and Path nodes can't
11 * be handled easily in a simple depth-first traversal.
12 *
13 * Currently, in fact, equal() doesn't know how to compare Plan trees
14 * either. This might need to be fixed someday.
15 *
16 * NOTE: it is intentional that parse location fields (in nodes that have
17 * one) are not compared. This is because we want, for example, a variable
18 * "x" to be considered equal() to another reference to "x" in the query.
19 *
20 *
21 * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
22 * Portions Copyright (c) 1994, Regents of the University of California
23 *
24 * IDENTIFICATION
25 * src/backend/nodes/equalfuncs.c
26 *
27 *-------------------------------------------------------------------------
28 */
29
30 #include "postgres.h"
31
32 #include "miscadmin.h"
33 #include "nodes/extensible.h"
34 #include "nodes/pathnodes.h"
35 #include "utils/datum.h"
36
37
38 /*
39 * Macros to simplify comparison of different kinds of fields. Use these
40 * wherever possible to reduce the chance for silly typos. Note that these
41 * hard-wire the convention that the local variables in an Equal routine are
42 * named 'a' and 'b'.
43 */
44
45 /* Compare a simple scalar field (int, float, bool, enum, etc) */
46 #define COMPARE_SCALAR_FIELD(fldname) \
47 do { \
48 if (a->fldname != b->fldname) \
49 return false; \
50 } while (0)
51
52 /* Compare a field that is a pointer to some kind of Node or Node tree */
53 #define COMPARE_NODE_FIELD(fldname) \
54 do { \
55 if (!equal(a->fldname, b->fldname)) \
56 return false; \
57 } while (0)
58
59 /* Compare a field that is a pointer to a Bitmapset */
60 #define COMPARE_BITMAPSET_FIELD(fldname) \
61 do { \
62 if (!bms_equal(a->fldname, b->fldname)) \
63 return false; \
64 } while (0)
65
66 /* Compare a field that is a pointer to a C string, or perhaps NULL */
67 #define COMPARE_STRING_FIELD(fldname) \
68 do { \
69 if (!equalstr(a->fldname, b->fldname)) \
70 return false; \
71 } while (0)
72
73 /* Macro for comparing string fields that might be NULL */
74 #define equalstr(a, b) \
75 (((a) != NULL && (b) != NULL) ? (strcmp(a, b) == 0) : (a) == (b))
76
77 /* Compare a field that is a pointer to a simple palloc'd object of size sz */
78 #define COMPARE_POINTER_FIELD(fldname, sz) \
79 do { \
80 if (memcmp(a->fldname, b->fldname, (sz)) != 0) \
81 return false; \
82 } while (0)
83
84 /* Compare a parse location field (this is a no-op, per note above) */
85 #define COMPARE_LOCATION_FIELD(fldname) \
86 ((void) 0)
87
88 /* Compare a CoercionForm field (also a no-op, per comment in primnodes.h) */
89 #define COMPARE_COERCIONFORM_FIELD(fldname) \
90 ((void) 0)
91
92
93 /*
94 * Stuff from primnodes.h
95 */
96
97 static bool
_equalAlias(const Alias * a,const Alias * b)98 _equalAlias(const Alias *a, const Alias *b)
99 {
100 COMPARE_STRING_FIELD(aliasname);
101 COMPARE_NODE_FIELD(colnames);
102
103 return true;
104 }
105
106 static bool
_equalRangeVar(const RangeVar * a,const RangeVar * b)107 _equalRangeVar(const RangeVar *a, const RangeVar *b)
108 {
109 COMPARE_STRING_FIELD(catalogname);
110 COMPARE_STRING_FIELD(schemaname);
111 COMPARE_STRING_FIELD(relname);
112 COMPARE_SCALAR_FIELD(inh);
113 COMPARE_SCALAR_FIELD(relpersistence);
114 COMPARE_NODE_FIELD(alias);
115 COMPARE_LOCATION_FIELD(location);
116
117 return true;
118 }
119
120 static bool
_equalTableFunc(const TableFunc * a,const TableFunc * b)121 _equalTableFunc(const TableFunc *a, const TableFunc *b)
122 {
123 COMPARE_NODE_FIELD(ns_uris);
124 COMPARE_NODE_FIELD(ns_names);
125 COMPARE_NODE_FIELD(docexpr);
126 COMPARE_NODE_FIELD(rowexpr);
127 COMPARE_NODE_FIELD(colnames);
128 COMPARE_NODE_FIELD(coltypes);
129 COMPARE_NODE_FIELD(coltypmods);
130 COMPARE_NODE_FIELD(colcollations);
131 COMPARE_NODE_FIELD(colexprs);
132 COMPARE_NODE_FIELD(coldefexprs);
133 COMPARE_BITMAPSET_FIELD(notnulls);
134 COMPARE_SCALAR_FIELD(ordinalitycol);
135 COMPARE_LOCATION_FIELD(location);
136
137 return true;
138 }
139
140 static bool
_equalIntoClause(const IntoClause * a,const IntoClause * b)141 _equalIntoClause(const IntoClause *a, const IntoClause *b)
142 {
143 COMPARE_NODE_FIELD(rel);
144 COMPARE_NODE_FIELD(colNames);
145 COMPARE_STRING_FIELD(accessMethod);
146 COMPARE_NODE_FIELD(options);
147 COMPARE_SCALAR_FIELD(onCommit);
148 COMPARE_STRING_FIELD(tableSpaceName);
149 COMPARE_NODE_FIELD(viewQuery);
150 COMPARE_SCALAR_FIELD(skipData);
151
152 return true;
153 }
154
155 /*
156 * We don't need an _equalExpr because Expr is an abstract supertype which
157 * should never actually get instantiated. Also, since it has no common
158 * fields except NodeTag, there's no need for a helper routine to factor
159 * out comparing the common fields...
160 */
161
162 static bool
_equalVar(const Var * a,const Var * b)163 _equalVar(const Var *a, const Var *b)
164 {
165 COMPARE_SCALAR_FIELD(varno);
166 COMPARE_SCALAR_FIELD(varattno);
167 COMPARE_SCALAR_FIELD(vartype);
168 COMPARE_SCALAR_FIELD(vartypmod);
169 COMPARE_SCALAR_FIELD(varcollid);
170 COMPARE_SCALAR_FIELD(varlevelsup);
171 COMPARE_SCALAR_FIELD(varnoold);
172 COMPARE_SCALAR_FIELD(varoattno);
173 COMPARE_LOCATION_FIELD(location);
174
175 return true;
176 }
177
178 static bool
_equalConst(const Const * a,const Const * b)179 _equalConst(const Const *a, const Const *b)
180 {
181 COMPARE_SCALAR_FIELD(consttype);
182 COMPARE_SCALAR_FIELD(consttypmod);
183 COMPARE_SCALAR_FIELD(constcollid);
184 COMPARE_SCALAR_FIELD(constlen);
185 COMPARE_SCALAR_FIELD(constisnull);
186 COMPARE_SCALAR_FIELD(constbyval);
187 COMPARE_LOCATION_FIELD(location);
188
189 /*
190 * We treat all NULL constants of the same type as equal. Someday this
191 * might need to change? But datumIsEqual doesn't work on nulls, so...
192 */
193 if (a->constisnull)
194 return true;
195 return datumIsEqual(a->constvalue, b->constvalue,
196 a->constbyval, a->constlen);
197 }
198
199 static bool
_equalParam(const Param * a,const Param * b)200 _equalParam(const Param *a, const Param *b)
201 {
202 COMPARE_SCALAR_FIELD(paramkind);
203 COMPARE_SCALAR_FIELD(paramid);
204 COMPARE_SCALAR_FIELD(paramtype);
205 COMPARE_SCALAR_FIELD(paramtypmod);
206 COMPARE_SCALAR_FIELD(paramcollid);
207 COMPARE_LOCATION_FIELD(location);
208
209 return true;
210 }
211
212 static bool
_equalAggref(const Aggref * a,const Aggref * b)213 _equalAggref(const Aggref *a, const Aggref *b)
214 {
215 COMPARE_SCALAR_FIELD(aggfnoid);
216 COMPARE_SCALAR_FIELD(aggtype);
217 COMPARE_SCALAR_FIELD(aggcollid);
218 COMPARE_SCALAR_FIELD(inputcollid);
219 /* ignore aggtranstype since it might not be set yet */
220 COMPARE_NODE_FIELD(aggargtypes);
221 COMPARE_NODE_FIELD(aggdirectargs);
222 COMPARE_NODE_FIELD(args);
223 COMPARE_NODE_FIELD(aggorder);
224 COMPARE_NODE_FIELD(aggdistinct);
225 COMPARE_NODE_FIELD(aggfilter);
226 COMPARE_SCALAR_FIELD(aggstar);
227 COMPARE_SCALAR_FIELD(aggvariadic);
228 COMPARE_SCALAR_FIELD(aggkind);
229 COMPARE_SCALAR_FIELD(agglevelsup);
230 COMPARE_SCALAR_FIELD(aggsplit);
231 COMPARE_LOCATION_FIELD(location);
232
233 return true;
234 }
235
236 static bool
_equalGroupingFunc(const GroupingFunc * a,const GroupingFunc * b)237 _equalGroupingFunc(const GroupingFunc *a, const GroupingFunc *b)
238 {
239 COMPARE_NODE_FIELD(args);
240
241 /*
242 * We must not compare the refs or cols field
243 */
244
245 COMPARE_SCALAR_FIELD(agglevelsup);
246 COMPARE_LOCATION_FIELD(location);
247
248 return true;
249 }
250
251 static bool
_equalWindowFunc(const WindowFunc * a,const WindowFunc * b)252 _equalWindowFunc(const WindowFunc *a, const WindowFunc *b)
253 {
254 COMPARE_SCALAR_FIELD(winfnoid);
255 COMPARE_SCALAR_FIELD(wintype);
256 COMPARE_SCALAR_FIELD(wincollid);
257 COMPARE_SCALAR_FIELD(inputcollid);
258 COMPARE_NODE_FIELD(args);
259 COMPARE_NODE_FIELD(aggfilter);
260 COMPARE_SCALAR_FIELD(winref);
261 COMPARE_SCALAR_FIELD(winstar);
262 COMPARE_SCALAR_FIELD(winagg);
263 COMPARE_LOCATION_FIELD(location);
264
265 return true;
266 }
267
268 static bool
_equalSubscriptingRef(const SubscriptingRef * a,const SubscriptingRef * b)269 _equalSubscriptingRef(const SubscriptingRef *a, const SubscriptingRef *b)
270 {
271 COMPARE_SCALAR_FIELD(refcontainertype);
272 COMPARE_SCALAR_FIELD(refelemtype);
273 COMPARE_SCALAR_FIELD(reftypmod);
274 COMPARE_SCALAR_FIELD(refcollid);
275 COMPARE_NODE_FIELD(refupperindexpr);
276 COMPARE_NODE_FIELD(reflowerindexpr);
277 COMPARE_NODE_FIELD(refexpr);
278 COMPARE_NODE_FIELD(refassgnexpr);
279
280 return true;
281 }
282
283 static bool
_equalFuncExpr(const FuncExpr * a,const FuncExpr * b)284 _equalFuncExpr(const FuncExpr *a, const FuncExpr *b)
285 {
286 COMPARE_SCALAR_FIELD(funcid);
287 COMPARE_SCALAR_FIELD(funcresulttype);
288 COMPARE_SCALAR_FIELD(funcretset);
289 COMPARE_SCALAR_FIELD(funcvariadic);
290 COMPARE_COERCIONFORM_FIELD(funcformat);
291 COMPARE_SCALAR_FIELD(funccollid);
292 COMPARE_SCALAR_FIELD(inputcollid);
293 COMPARE_NODE_FIELD(args);
294 COMPARE_LOCATION_FIELD(location);
295
296 return true;
297 }
298
299 static bool
_equalNamedArgExpr(const NamedArgExpr * a,const NamedArgExpr * b)300 _equalNamedArgExpr(const NamedArgExpr *a, const NamedArgExpr *b)
301 {
302 COMPARE_NODE_FIELD(arg);
303 COMPARE_STRING_FIELD(name);
304 COMPARE_SCALAR_FIELD(argnumber);
305 COMPARE_LOCATION_FIELD(location);
306
307 return true;
308 }
309
310 static bool
_equalOpExpr(const OpExpr * a,const OpExpr * b)311 _equalOpExpr(const OpExpr *a, const OpExpr *b)
312 {
313 COMPARE_SCALAR_FIELD(opno);
314
315 /*
316 * Special-case opfuncid: it is allowable for it to differ if one node
317 * contains zero and the other doesn't. This just means that the one node
318 * isn't as far along in the parse/plan pipeline and hasn't had the
319 * opfuncid cache filled yet.
320 */
321 if (a->opfuncid != b->opfuncid &&
322 a->opfuncid != 0 &&
323 b->opfuncid != 0)
324 return false;
325
326 COMPARE_SCALAR_FIELD(opresulttype);
327 COMPARE_SCALAR_FIELD(opretset);
328 COMPARE_SCALAR_FIELD(opcollid);
329 COMPARE_SCALAR_FIELD(inputcollid);
330 COMPARE_NODE_FIELD(args);
331 COMPARE_LOCATION_FIELD(location);
332
333 return true;
334 }
335
336 static bool
_equalDistinctExpr(const DistinctExpr * a,const DistinctExpr * b)337 _equalDistinctExpr(const DistinctExpr *a, const DistinctExpr *b)
338 {
339 COMPARE_SCALAR_FIELD(opno);
340
341 /*
342 * Special-case opfuncid: it is allowable for it to differ if one node
343 * contains zero and the other doesn't. This just means that the one node
344 * isn't as far along in the parse/plan pipeline and hasn't had the
345 * opfuncid cache filled yet.
346 */
347 if (a->opfuncid != b->opfuncid &&
348 a->opfuncid != 0 &&
349 b->opfuncid != 0)
350 return false;
351
352 COMPARE_SCALAR_FIELD(opresulttype);
353 COMPARE_SCALAR_FIELD(opretset);
354 COMPARE_SCALAR_FIELD(opcollid);
355 COMPARE_SCALAR_FIELD(inputcollid);
356 COMPARE_NODE_FIELD(args);
357 COMPARE_LOCATION_FIELD(location);
358
359 return true;
360 }
361
362 static bool
_equalNullIfExpr(const NullIfExpr * a,const NullIfExpr * b)363 _equalNullIfExpr(const NullIfExpr *a, const NullIfExpr *b)
364 {
365 COMPARE_SCALAR_FIELD(opno);
366
367 /*
368 * Special-case opfuncid: it is allowable for it to differ if one node
369 * contains zero and the other doesn't. This just means that the one node
370 * isn't as far along in the parse/plan pipeline and hasn't had the
371 * opfuncid cache filled yet.
372 */
373 if (a->opfuncid != b->opfuncid &&
374 a->opfuncid != 0 &&
375 b->opfuncid != 0)
376 return false;
377
378 COMPARE_SCALAR_FIELD(opresulttype);
379 COMPARE_SCALAR_FIELD(opretset);
380 COMPARE_SCALAR_FIELD(opcollid);
381 COMPARE_SCALAR_FIELD(inputcollid);
382 COMPARE_NODE_FIELD(args);
383 COMPARE_LOCATION_FIELD(location);
384
385 return true;
386 }
387
388 static bool
_equalScalarArrayOpExpr(const ScalarArrayOpExpr * a,const ScalarArrayOpExpr * b)389 _equalScalarArrayOpExpr(const ScalarArrayOpExpr *a, const ScalarArrayOpExpr *b)
390 {
391 COMPARE_SCALAR_FIELD(opno);
392
393 /*
394 * Special-case opfuncid: it is allowable for it to differ if one node
395 * contains zero and the other doesn't. This just means that the one node
396 * isn't as far along in the parse/plan pipeline and hasn't had the
397 * opfuncid cache filled yet.
398 */
399 if (a->opfuncid != b->opfuncid &&
400 a->opfuncid != 0 &&
401 b->opfuncid != 0)
402 return false;
403
404 COMPARE_SCALAR_FIELD(useOr);
405 COMPARE_SCALAR_FIELD(inputcollid);
406 COMPARE_NODE_FIELD(args);
407 COMPARE_LOCATION_FIELD(location);
408
409 return true;
410 }
411
412 static bool
_equalBoolExpr(const BoolExpr * a,const BoolExpr * b)413 _equalBoolExpr(const BoolExpr *a, const BoolExpr *b)
414 {
415 COMPARE_SCALAR_FIELD(boolop);
416 COMPARE_NODE_FIELD(args);
417 COMPARE_LOCATION_FIELD(location);
418
419 return true;
420 }
421
422 static bool
_equalSubLink(const SubLink * a,const SubLink * b)423 _equalSubLink(const SubLink *a, const SubLink *b)
424 {
425 COMPARE_SCALAR_FIELD(subLinkType);
426 COMPARE_SCALAR_FIELD(subLinkId);
427 COMPARE_NODE_FIELD(testexpr);
428 COMPARE_NODE_FIELD(operName);
429 COMPARE_NODE_FIELD(subselect);
430 COMPARE_LOCATION_FIELD(location);
431
432 return true;
433 }
434
435 static bool
_equalSubPlan(const SubPlan * a,const SubPlan * b)436 _equalSubPlan(const SubPlan *a, const SubPlan *b)
437 {
438 COMPARE_SCALAR_FIELD(subLinkType);
439 COMPARE_NODE_FIELD(testexpr);
440 COMPARE_NODE_FIELD(paramIds);
441 COMPARE_SCALAR_FIELD(plan_id);
442 COMPARE_STRING_FIELD(plan_name);
443 COMPARE_SCALAR_FIELD(firstColType);
444 COMPARE_SCALAR_FIELD(firstColTypmod);
445 COMPARE_SCALAR_FIELD(firstColCollation);
446 COMPARE_SCALAR_FIELD(useHashTable);
447 COMPARE_SCALAR_FIELD(unknownEqFalse);
448 COMPARE_SCALAR_FIELD(parallel_safe);
449 COMPARE_NODE_FIELD(setParam);
450 COMPARE_NODE_FIELD(parParam);
451 COMPARE_NODE_FIELD(args);
452 COMPARE_SCALAR_FIELD(startup_cost);
453 COMPARE_SCALAR_FIELD(per_call_cost);
454
455 return true;
456 }
457
458 static bool
_equalAlternativeSubPlan(const AlternativeSubPlan * a,const AlternativeSubPlan * b)459 _equalAlternativeSubPlan(const AlternativeSubPlan *a, const AlternativeSubPlan *b)
460 {
461 COMPARE_NODE_FIELD(subplans);
462
463 return true;
464 }
465
466 static bool
_equalFieldSelect(const FieldSelect * a,const FieldSelect * b)467 _equalFieldSelect(const FieldSelect *a, const FieldSelect *b)
468 {
469 COMPARE_NODE_FIELD(arg);
470 COMPARE_SCALAR_FIELD(fieldnum);
471 COMPARE_SCALAR_FIELD(resulttype);
472 COMPARE_SCALAR_FIELD(resulttypmod);
473 COMPARE_SCALAR_FIELD(resultcollid);
474
475 return true;
476 }
477
478 static bool
_equalFieldStore(const FieldStore * a,const FieldStore * b)479 _equalFieldStore(const FieldStore *a, const FieldStore *b)
480 {
481 COMPARE_NODE_FIELD(arg);
482 COMPARE_NODE_FIELD(newvals);
483 COMPARE_NODE_FIELD(fieldnums);
484 COMPARE_SCALAR_FIELD(resulttype);
485
486 return true;
487 }
488
489 static bool
_equalRelabelType(const RelabelType * a,const RelabelType * b)490 _equalRelabelType(const RelabelType *a, const RelabelType *b)
491 {
492 COMPARE_NODE_FIELD(arg);
493 COMPARE_SCALAR_FIELD(resulttype);
494 COMPARE_SCALAR_FIELD(resulttypmod);
495 COMPARE_SCALAR_FIELD(resultcollid);
496 COMPARE_COERCIONFORM_FIELD(relabelformat);
497 COMPARE_LOCATION_FIELD(location);
498
499 return true;
500 }
501
502 static bool
_equalCoerceViaIO(const CoerceViaIO * a,const CoerceViaIO * b)503 _equalCoerceViaIO(const CoerceViaIO *a, const CoerceViaIO *b)
504 {
505 COMPARE_NODE_FIELD(arg);
506 COMPARE_SCALAR_FIELD(resulttype);
507 COMPARE_SCALAR_FIELD(resultcollid);
508 COMPARE_COERCIONFORM_FIELD(coerceformat);
509 COMPARE_LOCATION_FIELD(location);
510
511 return true;
512 }
513
514 static bool
_equalArrayCoerceExpr(const ArrayCoerceExpr * a,const ArrayCoerceExpr * b)515 _equalArrayCoerceExpr(const ArrayCoerceExpr *a, const ArrayCoerceExpr *b)
516 {
517 COMPARE_NODE_FIELD(arg);
518 COMPARE_NODE_FIELD(elemexpr);
519 COMPARE_SCALAR_FIELD(resulttype);
520 COMPARE_SCALAR_FIELD(resulttypmod);
521 COMPARE_SCALAR_FIELD(resultcollid);
522 COMPARE_COERCIONFORM_FIELD(coerceformat);
523 COMPARE_LOCATION_FIELD(location);
524
525 return true;
526 }
527
528 static bool
_equalConvertRowtypeExpr(const ConvertRowtypeExpr * a,const ConvertRowtypeExpr * b)529 _equalConvertRowtypeExpr(const ConvertRowtypeExpr *a, const ConvertRowtypeExpr *b)
530 {
531 COMPARE_NODE_FIELD(arg);
532 COMPARE_SCALAR_FIELD(resulttype);
533 COMPARE_COERCIONFORM_FIELD(convertformat);
534 COMPARE_LOCATION_FIELD(location);
535
536 return true;
537 }
538
539 static bool
_equalCollateExpr(const CollateExpr * a,const CollateExpr * b)540 _equalCollateExpr(const CollateExpr *a, const CollateExpr *b)
541 {
542 COMPARE_NODE_FIELD(arg);
543 COMPARE_SCALAR_FIELD(collOid);
544 COMPARE_LOCATION_FIELD(location);
545
546 return true;
547 }
548
549 static bool
_equalCaseExpr(const CaseExpr * a,const CaseExpr * b)550 _equalCaseExpr(const CaseExpr *a, const CaseExpr *b)
551 {
552 COMPARE_SCALAR_FIELD(casetype);
553 COMPARE_SCALAR_FIELD(casecollid);
554 COMPARE_NODE_FIELD(arg);
555 COMPARE_NODE_FIELD(args);
556 COMPARE_NODE_FIELD(defresult);
557 COMPARE_LOCATION_FIELD(location);
558
559 return true;
560 }
561
562 static bool
_equalCaseWhen(const CaseWhen * a,const CaseWhen * b)563 _equalCaseWhen(const CaseWhen *a, const CaseWhen *b)
564 {
565 COMPARE_NODE_FIELD(expr);
566 COMPARE_NODE_FIELD(result);
567 COMPARE_LOCATION_FIELD(location);
568
569 return true;
570 }
571
572 static bool
_equalCaseTestExpr(const CaseTestExpr * a,const CaseTestExpr * b)573 _equalCaseTestExpr(const CaseTestExpr *a, const CaseTestExpr *b)
574 {
575 COMPARE_SCALAR_FIELD(typeId);
576 COMPARE_SCALAR_FIELD(typeMod);
577 COMPARE_SCALAR_FIELD(collation);
578
579 return true;
580 }
581
582 static bool
_equalArrayExpr(const ArrayExpr * a,const ArrayExpr * b)583 _equalArrayExpr(const ArrayExpr *a, const ArrayExpr *b)
584 {
585 COMPARE_SCALAR_FIELD(array_typeid);
586 COMPARE_SCALAR_FIELD(array_collid);
587 COMPARE_SCALAR_FIELD(element_typeid);
588 COMPARE_NODE_FIELD(elements);
589 COMPARE_SCALAR_FIELD(multidims);
590 COMPARE_LOCATION_FIELD(location);
591
592 return true;
593 }
594
595 static bool
_equalRowExpr(const RowExpr * a,const RowExpr * b)596 _equalRowExpr(const RowExpr *a, const RowExpr *b)
597 {
598 COMPARE_NODE_FIELD(args);
599 COMPARE_SCALAR_FIELD(row_typeid);
600 COMPARE_COERCIONFORM_FIELD(row_format);
601 COMPARE_NODE_FIELD(colnames);
602 COMPARE_LOCATION_FIELD(location);
603
604 return true;
605 }
606
607 static bool
_equalRowCompareExpr(const RowCompareExpr * a,const RowCompareExpr * b)608 _equalRowCompareExpr(const RowCompareExpr *a, const RowCompareExpr *b)
609 {
610 COMPARE_SCALAR_FIELD(rctype);
611 COMPARE_NODE_FIELD(opnos);
612 COMPARE_NODE_FIELD(opfamilies);
613 COMPARE_NODE_FIELD(inputcollids);
614 COMPARE_NODE_FIELD(largs);
615 COMPARE_NODE_FIELD(rargs);
616
617 return true;
618 }
619
620 static bool
_equalCoalesceExpr(const CoalesceExpr * a,const CoalesceExpr * b)621 _equalCoalesceExpr(const CoalesceExpr *a, const CoalesceExpr *b)
622 {
623 COMPARE_SCALAR_FIELD(coalescetype);
624 COMPARE_SCALAR_FIELD(coalescecollid);
625 COMPARE_NODE_FIELD(args);
626 COMPARE_LOCATION_FIELD(location);
627
628 return true;
629 }
630
631 static bool
_equalMinMaxExpr(const MinMaxExpr * a,const MinMaxExpr * b)632 _equalMinMaxExpr(const MinMaxExpr *a, const MinMaxExpr *b)
633 {
634 COMPARE_SCALAR_FIELD(minmaxtype);
635 COMPARE_SCALAR_FIELD(minmaxcollid);
636 COMPARE_SCALAR_FIELD(inputcollid);
637 COMPARE_SCALAR_FIELD(op);
638 COMPARE_NODE_FIELD(args);
639 COMPARE_LOCATION_FIELD(location);
640
641 return true;
642 }
643
644 static bool
_equalSQLValueFunction(const SQLValueFunction * a,const SQLValueFunction * b)645 _equalSQLValueFunction(const SQLValueFunction *a, const SQLValueFunction *b)
646 {
647 COMPARE_SCALAR_FIELD(op);
648 COMPARE_SCALAR_FIELD(type);
649 COMPARE_SCALAR_FIELD(typmod);
650 COMPARE_LOCATION_FIELD(location);
651
652 return true;
653 }
654
655 static bool
_equalXmlExpr(const XmlExpr * a,const XmlExpr * b)656 _equalXmlExpr(const XmlExpr *a, const XmlExpr *b)
657 {
658 COMPARE_SCALAR_FIELD(op);
659 COMPARE_STRING_FIELD(name);
660 COMPARE_NODE_FIELD(named_args);
661 COMPARE_NODE_FIELD(arg_names);
662 COMPARE_NODE_FIELD(args);
663 COMPARE_SCALAR_FIELD(xmloption);
664 COMPARE_SCALAR_FIELD(type);
665 COMPARE_SCALAR_FIELD(typmod);
666 COMPARE_LOCATION_FIELD(location);
667
668 return true;
669 }
670
671 static bool
_equalNullTest(const NullTest * a,const NullTest * b)672 _equalNullTest(const NullTest *a, const NullTest *b)
673 {
674 COMPARE_NODE_FIELD(arg);
675 COMPARE_SCALAR_FIELD(nulltesttype);
676 COMPARE_SCALAR_FIELD(argisrow);
677 COMPARE_LOCATION_FIELD(location);
678
679 return true;
680 }
681
682 static bool
_equalBooleanTest(const BooleanTest * a,const BooleanTest * b)683 _equalBooleanTest(const BooleanTest *a, const BooleanTest *b)
684 {
685 COMPARE_NODE_FIELD(arg);
686 COMPARE_SCALAR_FIELD(booltesttype);
687 COMPARE_LOCATION_FIELD(location);
688
689 return true;
690 }
691
692 static bool
_equalCoerceToDomain(const CoerceToDomain * a,const CoerceToDomain * b)693 _equalCoerceToDomain(const CoerceToDomain *a, const CoerceToDomain *b)
694 {
695 COMPARE_NODE_FIELD(arg);
696 COMPARE_SCALAR_FIELD(resulttype);
697 COMPARE_SCALAR_FIELD(resulttypmod);
698 COMPARE_SCALAR_FIELD(resultcollid);
699 COMPARE_COERCIONFORM_FIELD(coercionformat);
700 COMPARE_LOCATION_FIELD(location);
701
702 return true;
703 }
704
705 static bool
_equalCoerceToDomainValue(const CoerceToDomainValue * a,const CoerceToDomainValue * b)706 _equalCoerceToDomainValue(const CoerceToDomainValue *a, const CoerceToDomainValue *b)
707 {
708 COMPARE_SCALAR_FIELD(typeId);
709 COMPARE_SCALAR_FIELD(typeMod);
710 COMPARE_SCALAR_FIELD(collation);
711 COMPARE_LOCATION_FIELD(location);
712
713 return true;
714 }
715
716 static bool
_equalSetToDefault(const SetToDefault * a,const SetToDefault * b)717 _equalSetToDefault(const SetToDefault *a, const SetToDefault *b)
718 {
719 COMPARE_SCALAR_FIELD(typeId);
720 COMPARE_SCALAR_FIELD(typeMod);
721 COMPARE_SCALAR_FIELD(collation);
722 COMPARE_LOCATION_FIELD(location);
723
724 return true;
725 }
726
727 static bool
_equalCurrentOfExpr(const CurrentOfExpr * a,const CurrentOfExpr * b)728 _equalCurrentOfExpr(const CurrentOfExpr *a, const CurrentOfExpr *b)
729 {
730 COMPARE_SCALAR_FIELD(cvarno);
731 COMPARE_STRING_FIELD(cursor_name);
732 COMPARE_SCALAR_FIELD(cursor_param);
733
734 return true;
735 }
736
737 static bool
_equalNextValueExpr(const NextValueExpr * a,const NextValueExpr * b)738 _equalNextValueExpr(const NextValueExpr *a, const NextValueExpr *b)
739 {
740 COMPARE_SCALAR_FIELD(seqid);
741 COMPARE_SCALAR_FIELD(typeId);
742
743 return true;
744 }
745
746 static bool
_equalInferenceElem(const InferenceElem * a,const InferenceElem * b)747 _equalInferenceElem(const InferenceElem *a, const InferenceElem *b)
748 {
749 COMPARE_NODE_FIELD(expr);
750 COMPARE_SCALAR_FIELD(infercollid);
751 COMPARE_SCALAR_FIELD(inferopclass);
752
753 return true;
754 }
755
756 static bool
_equalTargetEntry(const TargetEntry * a,const TargetEntry * b)757 _equalTargetEntry(const TargetEntry *a, const TargetEntry *b)
758 {
759 COMPARE_NODE_FIELD(expr);
760 COMPARE_SCALAR_FIELD(resno);
761 COMPARE_STRING_FIELD(resname);
762 COMPARE_SCALAR_FIELD(ressortgroupref);
763 COMPARE_SCALAR_FIELD(resorigtbl);
764 COMPARE_SCALAR_FIELD(resorigcol);
765 COMPARE_SCALAR_FIELD(resjunk);
766
767 return true;
768 }
769
770 static bool
_equalRangeTblRef(const RangeTblRef * a,const RangeTblRef * b)771 _equalRangeTblRef(const RangeTblRef *a, const RangeTblRef *b)
772 {
773 COMPARE_SCALAR_FIELD(rtindex);
774
775 return true;
776 }
777
778 static bool
_equalJoinExpr(const JoinExpr * a,const JoinExpr * b)779 _equalJoinExpr(const JoinExpr *a, const JoinExpr *b)
780 {
781 COMPARE_SCALAR_FIELD(jointype);
782 COMPARE_SCALAR_FIELD(isNatural);
783 COMPARE_NODE_FIELD(larg);
784 COMPARE_NODE_FIELD(rarg);
785 COMPARE_NODE_FIELD(usingClause);
786 COMPARE_NODE_FIELD(quals);
787 COMPARE_NODE_FIELD(alias);
788 COMPARE_SCALAR_FIELD(rtindex);
789
790 return true;
791 }
792
793 static bool
_equalFromExpr(const FromExpr * a,const FromExpr * b)794 _equalFromExpr(const FromExpr *a, const FromExpr *b)
795 {
796 COMPARE_NODE_FIELD(fromlist);
797 COMPARE_NODE_FIELD(quals);
798
799 return true;
800 }
801
802 static bool
_equalOnConflictExpr(const OnConflictExpr * a,const OnConflictExpr * b)803 _equalOnConflictExpr(const OnConflictExpr *a, const OnConflictExpr *b)
804 {
805 COMPARE_SCALAR_FIELD(action);
806 COMPARE_NODE_FIELD(arbiterElems);
807 COMPARE_NODE_FIELD(arbiterWhere);
808 COMPARE_SCALAR_FIELD(constraint);
809 COMPARE_NODE_FIELD(onConflictSet);
810 COMPARE_NODE_FIELD(onConflictWhere);
811 COMPARE_SCALAR_FIELD(exclRelIndex);
812 COMPARE_NODE_FIELD(exclRelTlist);
813
814 return true;
815 }
816
817 /*
818 * Stuff from pathnodes.h
819 */
820
821 static bool
_equalPathKey(const PathKey * a,const PathKey * b)822 _equalPathKey(const PathKey *a, const PathKey *b)
823 {
824 /* We assume pointer equality is sufficient to compare the eclasses */
825 COMPARE_SCALAR_FIELD(pk_eclass);
826 COMPARE_SCALAR_FIELD(pk_opfamily);
827 COMPARE_SCALAR_FIELD(pk_strategy);
828 COMPARE_SCALAR_FIELD(pk_nulls_first);
829
830 return true;
831 }
832
833 static bool
_equalRestrictInfo(const RestrictInfo * a,const RestrictInfo * b)834 _equalRestrictInfo(const RestrictInfo *a, const RestrictInfo *b)
835 {
836 COMPARE_NODE_FIELD(clause);
837 COMPARE_SCALAR_FIELD(is_pushed_down);
838 COMPARE_SCALAR_FIELD(outerjoin_delayed);
839 COMPARE_SCALAR_FIELD(security_level);
840 COMPARE_BITMAPSET_FIELD(required_relids);
841 COMPARE_BITMAPSET_FIELD(outer_relids);
842 COMPARE_BITMAPSET_FIELD(nullable_relids);
843
844 /*
845 * We ignore all the remaining fields, since they may not be set yet, and
846 * should be derivable from the clause anyway.
847 */
848
849 return true;
850 }
851
852 static bool
_equalPlaceHolderVar(const PlaceHolderVar * a,const PlaceHolderVar * b)853 _equalPlaceHolderVar(const PlaceHolderVar *a, const PlaceHolderVar *b)
854 {
855 /*
856 * We intentionally do not compare phexpr. Two PlaceHolderVars with the
857 * same ID and levelsup should be considered equal even if the contained
858 * expressions have managed to mutate to different states. This will
859 * happen during final plan construction when there are nested PHVs, since
860 * the inner PHV will get replaced by a Param in some copies of the outer
861 * PHV. Another way in which it can happen is that initplan sublinks
862 * could get replaced by differently-numbered Params when sublink folding
863 * is done. (The end result of such a situation would be some
864 * unreferenced initplans, which is annoying but not really a problem.) On
865 * the same reasoning, there is no need to examine phrels.
866 *
867 * COMPARE_NODE_FIELD(phexpr);
868 *
869 * COMPARE_BITMAPSET_FIELD(phrels);
870 */
871 COMPARE_SCALAR_FIELD(phid);
872 COMPARE_SCALAR_FIELD(phlevelsup);
873
874 return true;
875 }
876
877 static bool
_equalSpecialJoinInfo(const SpecialJoinInfo * a,const SpecialJoinInfo * b)878 _equalSpecialJoinInfo(const SpecialJoinInfo *a, const SpecialJoinInfo *b)
879 {
880 COMPARE_BITMAPSET_FIELD(min_lefthand);
881 COMPARE_BITMAPSET_FIELD(min_righthand);
882 COMPARE_BITMAPSET_FIELD(syn_lefthand);
883 COMPARE_BITMAPSET_FIELD(syn_righthand);
884 COMPARE_SCALAR_FIELD(jointype);
885 COMPARE_SCALAR_FIELD(lhs_strict);
886 COMPARE_SCALAR_FIELD(delay_upper_joins);
887 COMPARE_SCALAR_FIELD(semi_can_btree);
888 COMPARE_SCALAR_FIELD(semi_can_hash);
889 COMPARE_NODE_FIELD(semi_operators);
890 COMPARE_NODE_FIELD(semi_rhs_exprs);
891
892 return true;
893 }
894
895 static bool
_equalAppendRelInfo(const AppendRelInfo * a,const AppendRelInfo * b)896 _equalAppendRelInfo(const AppendRelInfo *a, const AppendRelInfo *b)
897 {
898 COMPARE_SCALAR_FIELD(parent_relid);
899 COMPARE_SCALAR_FIELD(child_relid);
900 COMPARE_SCALAR_FIELD(parent_reltype);
901 COMPARE_SCALAR_FIELD(child_reltype);
902 COMPARE_NODE_FIELD(translated_vars);
903 COMPARE_SCALAR_FIELD(parent_reloid);
904
905 return true;
906 }
907
908 static bool
_equalPlaceHolderInfo(const PlaceHolderInfo * a,const PlaceHolderInfo * b)909 _equalPlaceHolderInfo(const PlaceHolderInfo *a, const PlaceHolderInfo *b)
910 {
911 COMPARE_SCALAR_FIELD(phid);
912 COMPARE_NODE_FIELD(ph_var); /* should be redundant */
913 COMPARE_BITMAPSET_FIELD(ph_eval_at);
914 COMPARE_BITMAPSET_FIELD(ph_lateral);
915 COMPARE_BITMAPSET_FIELD(ph_needed);
916 COMPARE_SCALAR_FIELD(ph_width);
917
918 return true;
919 }
920
921 /*
922 * Stuff from extensible.h
923 */
924 static bool
_equalExtensibleNode(const ExtensibleNode * a,const ExtensibleNode * b)925 _equalExtensibleNode(const ExtensibleNode *a, const ExtensibleNode *b)
926 {
927 const ExtensibleNodeMethods *methods;
928
929 COMPARE_STRING_FIELD(extnodename);
930
931 /* At this point, we know extnodename is the same for both nodes. */
932 methods = GetExtensibleNodeMethods(a->extnodename, false);
933
934 /* compare the private fields */
935 if (!methods->nodeEqual(a, b))
936 return false;
937
938 return true;
939 }
940
941 /*
942 * Stuff from parsenodes.h
943 */
944
945 static bool
_equalQuery(const Query * a,const Query * b)946 _equalQuery(const Query *a, const Query *b)
947 {
948 COMPARE_SCALAR_FIELD(commandType);
949 COMPARE_SCALAR_FIELD(querySource);
950 /* we intentionally ignore queryId, since it might not be set */
951 COMPARE_SCALAR_FIELD(canSetTag);
952 COMPARE_NODE_FIELD(utilityStmt);
953 COMPARE_SCALAR_FIELD(resultRelation);
954 COMPARE_SCALAR_FIELD(hasAggs);
955 COMPARE_SCALAR_FIELD(hasWindowFuncs);
956 COMPARE_SCALAR_FIELD(hasTargetSRFs);
957 COMPARE_SCALAR_FIELD(hasSubLinks);
958 COMPARE_SCALAR_FIELD(hasDistinctOn);
959 COMPARE_SCALAR_FIELD(hasRecursive);
960 COMPARE_SCALAR_FIELD(hasModifyingCTE);
961 COMPARE_SCALAR_FIELD(hasForUpdate);
962 COMPARE_SCALAR_FIELD(hasRowSecurity);
963 COMPARE_NODE_FIELD(cteList);
964 COMPARE_NODE_FIELD(rtable);
965 COMPARE_NODE_FIELD(jointree);
966 COMPARE_NODE_FIELD(targetList);
967 COMPARE_SCALAR_FIELD(override);
968 COMPARE_NODE_FIELD(onConflict);
969 COMPARE_NODE_FIELD(returningList);
970 COMPARE_NODE_FIELD(groupClause);
971 COMPARE_NODE_FIELD(groupingSets);
972 COMPARE_NODE_FIELD(havingQual);
973 COMPARE_NODE_FIELD(windowClause);
974 COMPARE_NODE_FIELD(distinctClause);
975 COMPARE_NODE_FIELD(sortClause);
976 COMPARE_NODE_FIELD(limitOffset);
977 COMPARE_NODE_FIELD(limitCount);
978 COMPARE_NODE_FIELD(rowMarks);
979 COMPARE_NODE_FIELD(setOperations);
980 COMPARE_NODE_FIELD(constraintDeps);
981 COMPARE_NODE_FIELD(withCheckOptions);
982 COMPARE_LOCATION_FIELD(stmt_location);
983 COMPARE_LOCATION_FIELD(stmt_len);
984
985 return true;
986 }
987
988 static bool
_equalRawStmt(const RawStmt * a,const RawStmt * b)989 _equalRawStmt(const RawStmt *a, const RawStmt *b)
990 {
991 COMPARE_NODE_FIELD(stmt);
992 COMPARE_LOCATION_FIELD(stmt_location);
993 COMPARE_LOCATION_FIELD(stmt_len);
994
995 return true;
996 }
997
998 static bool
_equalInsertStmt(const InsertStmt * a,const InsertStmt * b)999 _equalInsertStmt(const InsertStmt *a, const InsertStmt *b)
1000 {
1001 COMPARE_NODE_FIELD(relation);
1002 COMPARE_NODE_FIELD(cols);
1003 COMPARE_NODE_FIELD(selectStmt);
1004 COMPARE_NODE_FIELD(onConflictClause);
1005 COMPARE_NODE_FIELD(returningList);
1006 COMPARE_NODE_FIELD(withClause);
1007 COMPARE_SCALAR_FIELD(override);
1008
1009 return true;
1010 }
1011
1012 static bool
_equalDeleteStmt(const DeleteStmt * a,const DeleteStmt * b)1013 _equalDeleteStmt(const DeleteStmt *a, const DeleteStmt *b)
1014 {
1015 COMPARE_NODE_FIELD(relation);
1016 COMPARE_NODE_FIELD(usingClause);
1017 COMPARE_NODE_FIELD(whereClause);
1018 COMPARE_NODE_FIELD(returningList);
1019 COMPARE_NODE_FIELD(withClause);
1020
1021 return true;
1022 }
1023
1024 static bool
_equalUpdateStmt(const UpdateStmt * a,const UpdateStmt * b)1025 _equalUpdateStmt(const UpdateStmt *a, const UpdateStmt *b)
1026 {
1027 COMPARE_NODE_FIELD(relation);
1028 COMPARE_NODE_FIELD(targetList);
1029 COMPARE_NODE_FIELD(whereClause);
1030 COMPARE_NODE_FIELD(fromClause);
1031 COMPARE_NODE_FIELD(returningList);
1032 COMPARE_NODE_FIELD(withClause);
1033
1034 return true;
1035 }
1036
1037 static bool
_equalSelectStmt(const SelectStmt * a,const SelectStmt * b)1038 _equalSelectStmt(const SelectStmt *a, const SelectStmt *b)
1039 {
1040 COMPARE_NODE_FIELD(distinctClause);
1041 COMPARE_NODE_FIELD(intoClause);
1042 COMPARE_NODE_FIELD(targetList);
1043 COMPARE_NODE_FIELD(fromClause);
1044 COMPARE_NODE_FIELD(whereClause);
1045 COMPARE_NODE_FIELD(groupClause);
1046 COMPARE_NODE_FIELD(havingClause);
1047 COMPARE_NODE_FIELD(windowClause);
1048 COMPARE_NODE_FIELD(valuesLists);
1049 COMPARE_NODE_FIELD(sortClause);
1050 COMPARE_NODE_FIELD(limitOffset);
1051 COMPARE_NODE_FIELD(limitCount);
1052 COMPARE_NODE_FIELD(lockingClause);
1053 COMPARE_NODE_FIELD(withClause);
1054 COMPARE_SCALAR_FIELD(op);
1055 COMPARE_SCALAR_FIELD(all);
1056 COMPARE_NODE_FIELD(larg);
1057 COMPARE_NODE_FIELD(rarg);
1058
1059 return true;
1060 }
1061
1062 static bool
_equalSetOperationStmt(const SetOperationStmt * a,const SetOperationStmt * b)1063 _equalSetOperationStmt(const SetOperationStmt *a, const SetOperationStmt *b)
1064 {
1065 COMPARE_SCALAR_FIELD(op);
1066 COMPARE_SCALAR_FIELD(all);
1067 COMPARE_NODE_FIELD(larg);
1068 COMPARE_NODE_FIELD(rarg);
1069 COMPARE_NODE_FIELD(colTypes);
1070 COMPARE_NODE_FIELD(colTypmods);
1071 COMPARE_NODE_FIELD(colCollations);
1072 COMPARE_NODE_FIELD(groupClauses);
1073
1074 return true;
1075 }
1076
1077 static bool
_equalAlterTableStmt(const AlterTableStmt * a,const AlterTableStmt * b)1078 _equalAlterTableStmt(const AlterTableStmt *a, const AlterTableStmt *b)
1079 {
1080 COMPARE_NODE_FIELD(relation);
1081 COMPARE_NODE_FIELD(cmds);
1082 COMPARE_SCALAR_FIELD(relkind);
1083 COMPARE_SCALAR_FIELD(missing_ok);
1084
1085 return true;
1086 }
1087
1088 static bool
_equalAlterTableCmd(const AlterTableCmd * a,const AlterTableCmd * b)1089 _equalAlterTableCmd(const AlterTableCmd *a, const AlterTableCmd *b)
1090 {
1091 COMPARE_SCALAR_FIELD(subtype);
1092 COMPARE_STRING_FIELD(name);
1093 COMPARE_SCALAR_FIELD(num);
1094 COMPARE_NODE_FIELD(newowner);
1095 COMPARE_NODE_FIELD(def);
1096 COMPARE_SCALAR_FIELD(behavior);
1097 COMPARE_SCALAR_FIELD(missing_ok);
1098
1099 return true;
1100 }
1101
1102 static bool
_equalAlterCollationStmt(const AlterCollationStmt * a,const AlterCollationStmt * b)1103 _equalAlterCollationStmt(const AlterCollationStmt *a, const AlterCollationStmt *b)
1104 {
1105 COMPARE_NODE_FIELD(collname);
1106
1107 return true;
1108 }
1109
1110 static bool
_equalAlterDomainStmt(const AlterDomainStmt * a,const AlterDomainStmt * b)1111 _equalAlterDomainStmt(const AlterDomainStmt *a, const AlterDomainStmt *b)
1112 {
1113 COMPARE_SCALAR_FIELD(subtype);
1114 COMPARE_NODE_FIELD(typeName);
1115 COMPARE_STRING_FIELD(name);
1116 COMPARE_NODE_FIELD(def);
1117 COMPARE_SCALAR_FIELD(behavior);
1118 COMPARE_SCALAR_FIELD(missing_ok);
1119
1120 return true;
1121 }
1122
1123 static bool
_equalGrantStmt(const GrantStmt * a,const GrantStmt * b)1124 _equalGrantStmt(const GrantStmt *a, const GrantStmt *b)
1125 {
1126 COMPARE_SCALAR_FIELD(is_grant);
1127 COMPARE_SCALAR_FIELD(targtype);
1128 COMPARE_SCALAR_FIELD(objtype);
1129 COMPARE_NODE_FIELD(objects);
1130 COMPARE_NODE_FIELD(privileges);
1131 COMPARE_NODE_FIELD(grantees);
1132 COMPARE_SCALAR_FIELD(grant_option);
1133 COMPARE_SCALAR_FIELD(behavior);
1134
1135 return true;
1136 }
1137
1138 static bool
_equalObjectWithArgs(const ObjectWithArgs * a,const ObjectWithArgs * b)1139 _equalObjectWithArgs(const ObjectWithArgs *a, const ObjectWithArgs *b)
1140 {
1141 COMPARE_NODE_FIELD(objname);
1142 COMPARE_NODE_FIELD(objargs);
1143 COMPARE_SCALAR_FIELD(args_unspecified);
1144
1145 return true;
1146 }
1147
1148 static bool
_equalAccessPriv(const AccessPriv * a,const AccessPriv * b)1149 _equalAccessPriv(const AccessPriv *a, const AccessPriv *b)
1150 {
1151 COMPARE_STRING_FIELD(priv_name);
1152 COMPARE_NODE_FIELD(cols);
1153
1154 return true;
1155 }
1156
1157 static bool
_equalGrantRoleStmt(const GrantRoleStmt * a,const GrantRoleStmt * b)1158 _equalGrantRoleStmt(const GrantRoleStmt *a, const GrantRoleStmt *b)
1159 {
1160 COMPARE_NODE_FIELD(granted_roles);
1161 COMPARE_NODE_FIELD(grantee_roles);
1162 COMPARE_SCALAR_FIELD(is_grant);
1163 COMPARE_SCALAR_FIELD(admin_opt);
1164 COMPARE_NODE_FIELD(grantor);
1165 COMPARE_SCALAR_FIELD(behavior);
1166
1167 return true;
1168 }
1169
1170 static bool
_equalAlterDefaultPrivilegesStmt(const AlterDefaultPrivilegesStmt * a,const AlterDefaultPrivilegesStmt * b)1171 _equalAlterDefaultPrivilegesStmt(const AlterDefaultPrivilegesStmt *a, const AlterDefaultPrivilegesStmt *b)
1172 {
1173 COMPARE_NODE_FIELD(options);
1174 COMPARE_NODE_FIELD(action);
1175
1176 return true;
1177 }
1178
1179 static bool
_equalDeclareCursorStmt(const DeclareCursorStmt * a,const DeclareCursorStmt * b)1180 _equalDeclareCursorStmt(const DeclareCursorStmt *a, const DeclareCursorStmt *b)
1181 {
1182 COMPARE_STRING_FIELD(portalname);
1183 COMPARE_SCALAR_FIELD(options);
1184 COMPARE_NODE_FIELD(query);
1185
1186 return true;
1187 }
1188
1189 static bool
_equalClosePortalStmt(const ClosePortalStmt * a,const ClosePortalStmt * b)1190 _equalClosePortalStmt(const ClosePortalStmt *a, const ClosePortalStmt *b)
1191 {
1192 COMPARE_STRING_FIELD(portalname);
1193
1194 return true;
1195 }
1196
1197 static bool
_equalCallStmt(const CallStmt * a,const CallStmt * b)1198 _equalCallStmt(const CallStmt *a, const CallStmt *b)
1199 {
1200 COMPARE_NODE_FIELD(funccall);
1201 COMPARE_NODE_FIELD(funcexpr);
1202
1203 return true;
1204 }
1205
1206 static bool
_equalClusterStmt(const ClusterStmt * a,const ClusterStmt * b)1207 _equalClusterStmt(const ClusterStmt *a, const ClusterStmt *b)
1208 {
1209 COMPARE_NODE_FIELD(relation);
1210 COMPARE_STRING_FIELD(indexname);
1211 COMPARE_SCALAR_FIELD(options);
1212
1213 return true;
1214 }
1215
1216 static bool
_equalCopyStmt(const CopyStmt * a,const CopyStmt * b)1217 _equalCopyStmt(const CopyStmt *a, const CopyStmt *b)
1218 {
1219 COMPARE_NODE_FIELD(relation);
1220 COMPARE_NODE_FIELD(query);
1221 COMPARE_NODE_FIELD(attlist);
1222 COMPARE_SCALAR_FIELD(is_from);
1223 COMPARE_SCALAR_FIELD(is_program);
1224 COMPARE_STRING_FIELD(filename);
1225 COMPARE_NODE_FIELD(options);
1226 COMPARE_NODE_FIELD(whereClause);
1227
1228 return true;
1229 }
1230
1231 static bool
_equalCreateStmt(const CreateStmt * a,const CreateStmt * b)1232 _equalCreateStmt(const CreateStmt *a, const CreateStmt *b)
1233 {
1234 COMPARE_NODE_FIELD(relation);
1235 COMPARE_NODE_FIELD(tableElts);
1236 COMPARE_NODE_FIELD(inhRelations);
1237 COMPARE_NODE_FIELD(partbound);
1238 COMPARE_NODE_FIELD(partspec);
1239 COMPARE_NODE_FIELD(ofTypename);
1240 COMPARE_NODE_FIELD(constraints);
1241 COMPARE_NODE_FIELD(options);
1242 COMPARE_SCALAR_FIELD(oncommit);
1243 COMPARE_STRING_FIELD(tablespacename);
1244 COMPARE_STRING_FIELD(accessMethod);
1245 COMPARE_SCALAR_FIELD(if_not_exists);
1246
1247 return true;
1248 }
1249
1250 static bool
_equalTableLikeClause(const TableLikeClause * a,const TableLikeClause * b)1251 _equalTableLikeClause(const TableLikeClause *a, const TableLikeClause *b)
1252 {
1253 COMPARE_NODE_FIELD(relation);
1254 COMPARE_SCALAR_FIELD(options);
1255 COMPARE_SCALAR_FIELD(relationOid);
1256
1257 return true;
1258 }
1259
1260 static bool
_equalDefineStmt(const DefineStmt * a,const DefineStmt * b)1261 _equalDefineStmt(const DefineStmt *a, const DefineStmt *b)
1262 {
1263 COMPARE_SCALAR_FIELD(kind);
1264 COMPARE_SCALAR_FIELD(oldstyle);
1265 COMPARE_NODE_FIELD(defnames);
1266 COMPARE_NODE_FIELD(args);
1267 COMPARE_NODE_FIELD(definition);
1268 COMPARE_SCALAR_FIELD(if_not_exists);
1269 COMPARE_SCALAR_FIELD(replace);
1270
1271 return true;
1272 }
1273
1274 static bool
_equalDropStmt(const DropStmt * a,const DropStmt * b)1275 _equalDropStmt(const DropStmt *a, const DropStmt *b)
1276 {
1277 COMPARE_NODE_FIELD(objects);
1278 COMPARE_SCALAR_FIELD(removeType);
1279 COMPARE_SCALAR_FIELD(behavior);
1280 COMPARE_SCALAR_FIELD(missing_ok);
1281 COMPARE_SCALAR_FIELD(concurrent);
1282
1283 return true;
1284 }
1285
1286 static bool
_equalTruncateStmt(const TruncateStmt * a,const TruncateStmt * b)1287 _equalTruncateStmt(const TruncateStmt *a, const TruncateStmt *b)
1288 {
1289 COMPARE_NODE_FIELD(relations);
1290 COMPARE_SCALAR_FIELD(restart_seqs);
1291 COMPARE_SCALAR_FIELD(behavior);
1292
1293 return true;
1294 }
1295
1296 static bool
_equalCommentStmt(const CommentStmt * a,const CommentStmt * b)1297 _equalCommentStmt(const CommentStmt *a, const CommentStmt *b)
1298 {
1299 COMPARE_SCALAR_FIELD(objtype);
1300 COMPARE_NODE_FIELD(object);
1301 COMPARE_STRING_FIELD(comment);
1302
1303 return true;
1304 }
1305
1306 static bool
_equalSecLabelStmt(const SecLabelStmt * a,const SecLabelStmt * b)1307 _equalSecLabelStmt(const SecLabelStmt *a, const SecLabelStmt *b)
1308 {
1309 COMPARE_SCALAR_FIELD(objtype);
1310 COMPARE_NODE_FIELD(object);
1311 COMPARE_STRING_FIELD(provider);
1312 COMPARE_STRING_FIELD(label);
1313
1314 return true;
1315 }
1316
1317 static bool
_equalFetchStmt(const FetchStmt * a,const FetchStmt * b)1318 _equalFetchStmt(const FetchStmt *a, const FetchStmt *b)
1319 {
1320 COMPARE_SCALAR_FIELD(direction);
1321 COMPARE_SCALAR_FIELD(howMany);
1322 COMPARE_STRING_FIELD(portalname);
1323 COMPARE_SCALAR_FIELD(ismove);
1324
1325 return true;
1326 }
1327
1328 static bool
_equalIndexStmt(const IndexStmt * a,const IndexStmt * b)1329 _equalIndexStmt(const IndexStmt *a, const IndexStmt *b)
1330 {
1331 COMPARE_STRING_FIELD(idxname);
1332 COMPARE_NODE_FIELD(relation);
1333 COMPARE_STRING_FIELD(accessMethod);
1334 COMPARE_STRING_FIELD(tableSpace);
1335 COMPARE_NODE_FIELD(indexParams);
1336 COMPARE_NODE_FIELD(indexIncludingParams);
1337 COMPARE_NODE_FIELD(options);
1338 COMPARE_NODE_FIELD(whereClause);
1339 COMPARE_NODE_FIELD(excludeOpNames);
1340 COMPARE_STRING_FIELD(idxcomment);
1341 COMPARE_SCALAR_FIELD(indexOid);
1342 COMPARE_SCALAR_FIELD(oldNode);
1343 COMPARE_SCALAR_FIELD(unique);
1344 COMPARE_SCALAR_FIELD(primary);
1345 COMPARE_SCALAR_FIELD(isconstraint);
1346 COMPARE_SCALAR_FIELD(deferrable);
1347 COMPARE_SCALAR_FIELD(initdeferred);
1348 COMPARE_SCALAR_FIELD(transformed);
1349 COMPARE_SCALAR_FIELD(concurrent);
1350 COMPARE_SCALAR_FIELD(if_not_exists);
1351 COMPARE_SCALAR_FIELD(reset_default_tblspc);
1352
1353 return true;
1354 }
1355
1356 static bool
_equalCreateStatsStmt(const CreateStatsStmt * a,const CreateStatsStmt * b)1357 _equalCreateStatsStmt(const CreateStatsStmt *a, const CreateStatsStmt *b)
1358 {
1359 COMPARE_NODE_FIELD(defnames);
1360 COMPARE_NODE_FIELD(stat_types);
1361 COMPARE_NODE_FIELD(exprs);
1362 COMPARE_NODE_FIELD(relations);
1363 COMPARE_STRING_FIELD(stxcomment);
1364 COMPARE_SCALAR_FIELD(if_not_exists);
1365
1366 return true;
1367 }
1368
1369 static bool
_equalCreateFunctionStmt(const CreateFunctionStmt * a,const CreateFunctionStmt * b)1370 _equalCreateFunctionStmt(const CreateFunctionStmt *a, const CreateFunctionStmt *b)
1371 {
1372 COMPARE_SCALAR_FIELD(is_procedure);
1373 COMPARE_SCALAR_FIELD(replace);
1374 COMPARE_NODE_FIELD(funcname);
1375 COMPARE_NODE_FIELD(parameters);
1376 COMPARE_NODE_FIELD(returnType);
1377 COMPARE_NODE_FIELD(options);
1378
1379 return true;
1380 }
1381
1382 static bool
_equalFunctionParameter(const FunctionParameter * a,const FunctionParameter * b)1383 _equalFunctionParameter(const FunctionParameter *a, const FunctionParameter *b)
1384 {
1385 COMPARE_STRING_FIELD(name);
1386 COMPARE_NODE_FIELD(argType);
1387 COMPARE_SCALAR_FIELD(mode);
1388 COMPARE_NODE_FIELD(defexpr);
1389
1390 return true;
1391 }
1392
1393 static bool
_equalAlterFunctionStmt(const AlterFunctionStmt * a,const AlterFunctionStmt * b)1394 _equalAlterFunctionStmt(const AlterFunctionStmt *a, const AlterFunctionStmt *b)
1395 {
1396 COMPARE_SCALAR_FIELD(objtype);
1397 COMPARE_NODE_FIELD(func);
1398 COMPARE_NODE_FIELD(actions);
1399
1400 return true;
1401 }
1402
1403 static bool
_equalDoStmt(const DoStmt * a,const DoStmt * b)1404 _equalDoStmt(const DoStmt *a, const DoStmt *b)
1405 {
1406 COMPARE_NODE_FIELD(args);
1407
1408 return true;
1409 }
1410
1411 static bool
_equalRenameStmt(const RenameStmt * a,const RenameStmt * b)1412 _equalRenameStmt(const RenameStmt *a, const RenameStmt *b)
1413 {
1414 COMPARE_SCALAR_FIELD(renameType);
1415 COMPARE_SCALAR_FIELD(relationType);
1416 COMPARE_NODE_FIELD(relation);
1417 COMPARE_NODE_FIELD(object);
1418 COMPARE_STRING_FIELD(subname);
1419 COMPARE_STRING_FIELD(newname);
1420 COMPARE_SCALAR_FIELD(behavior);
1421 COMPARE_SCALAR_FIELD(missing_ok);
1422
1423 return true;
1424 }
1425
1426 static bool
_equalAlterObjectDependsStmt(const AlterObjectDependsStmt * a,const AlterObjectDependsStmt * b)1427 _equalAlterObjectDependsStmt(const AlterObjectDependsStmt *a, const AlterObjectDependsStmt *b)
1428 {
1429 COMPARE_SCALAR_FIELD(objectType);
1430 COMPARE_NODE_FIELD(relation);
1431 COMPARE_NODE_FIELD(object);
1432 COMPARE_NODE_FIELD(extname);
1433
1434 return true;
1435 }
1436
1437 static bool
_equalAlterObjectSchemaStmt(const AlterObjectSchemaStmt * a,const AlterObjectSchemaStmt * b)1438 _equalAlterObjectSchemaStmt(const AlterObjectSchemaStmt *a, const AlterObjectSchemaStmt *b)
1439 {
1440 COMPARE_SCALAR_FIELD(objectType);
1441 COMPARE_NODE_FIELD(relation);
1442 COMPARE_NODE_FIELD(object);
1443 COMPARE_STRING_FIELD(newschema);
1444 COMPARE_SCALAR_FIELD(missing_ok);
1445
1446 return true;
1447 }
1448
1449 static bool
_equalAlterOwnerStmt(const AlterOwnerStmt * a,const AlterOwnerStmt * b)1450 _equalAlterOwnerStmt(const AlterOwnerStmt *a, const AlterOwnerStmt *b)
1451 {
1452 COMPARE_SCALAR_FIELD(objectType);
1453 COMPARE_NODE_FIELD(relation);
1454 COMPARE_NODE_FIELD(object);
1455 COMPARE_NODE_FIELD(newowner);
1456
1457 return true;
1458 }
1459
1460 static bool
_equalAlterOperatorStmt(const AlterOperatorStmt * a,const AlterOperatorStmt * b)1461 _equalAlterOperatorStmt(const AlterOperatorStmt *a, const AlterOperatorStmt *b)
1462 {
1463 COMPARE_NODE_FIELD(opername);
1464 COMPARE_NODE_FIELD(options);
1465
1466 return true;
1467 }
1468
1469 static bool
_equalRuleStmt(const RuleStmt * a,const RuleStmt * b)1470 _equalRuleStmt(const RuleStmt *a, const RuleStmt *b)
1471 {
1472 COMPARE_NODE_FIELD(relation);
1473 COMPARE_STRING_FIELD(rulename);
1474 COMPARE_NODE_FIELD(whereClause);
1475 COMPARE_SCALAR_FIELD(event);
1476 COMPARE_SCALAR_FIELD(instead);
1477 COMPARE_NODE_FIELD(actions);
1478 COMPARE_SCALAR_FIELD(replace);
1479
1480 return true;
1481 }
1482
1483 static bool
_equalNotifyStmt(const NotifyStmt * a,const NotifyStmt * b)1484 _equalNotifyStmt(const NotifyStmt *a, const NotifyStmt *b)
1485 {
1486 COMPARE_STRING_FIELD(conditionname);
1487 COMPARE_STRING_FIELD(payload);
1488
1489 return true;
1490 }
1491
1492 static bool
_equalListenStmt(const ListenStmt * a,const ListenStmt * b)1493 _equalListenStmt(const ListenStmt *a, const ListenStmt *b)
1494 {
1495 COMPARE_STRING_FIELD(conditionname);
1496
1497 return true;
1498 }
1499
1500 static bool
_equalUnlistenStmt(const UnlistenStmt * a,const UnlistenStmt * b)1501 _equalUnlistenStmt(const UnlistenStmt *a, const UnlistenStmt *b)
1502 {
1503 COMPARE_STRING_FIELD(conditionname);
1504
1505 return true;
1506 }
1507
1508 static bool
_equalTransactionStmt(const TransactionStmt * a,const TransactionStmt * b)1509 _equalTransactionStmt(const TransactionStmt *a, const TransactionStmt *b)
1510 {
1511 COMPARE_SCALAR_FIELD(kind);
1512 COMPARE_NODE_FIELD(options);
1513 COMPARE_STRING_FIELD(savepoint_name);
1514 COMPARE_STRING_FIELD(gid);
1515 COMPARE_SCALAR_FIELD(chain);
1516
1517 return true;
1518 }
1519
1520 static bool
_equalCompositeTypeStmt(const CompositeTypeStmt * a,const CompositeTypeStmt * b)1521 _equalCompositeTypeStmt(const CompositeTypeStmt *a, const CompositeTypeStmt *b)
1522 {
1523 COMPARE_NODE_FIELD(typevar);
1524 COMPARE_NODE_FIELD(coldeflist);
1525
1526 return true;
1527 }
1528
1529 static bool
_equalCreateEnumStmt(const CreateEnumStmt * a,const CreateEnumStmt * b)1530 _equalCreateEnumStmt(const CreateEnumStmt *a, const CreateEnumStmt *b)
1531 {
1532 COMPARE_NODE_FIELD(typeName);
1533 COMPARE_NODE_FIELD(vals);
1534
1535 return true;
1536 }
1537
1538 static bool
_equalCreateRangeStmt(const CreateRangeStmt * a,const CreateRangeStmt * b)1539 _equalCreateRangeStmt(const CreateRangeStmt *a, const CreateRangeStmt *b)
1540 {
1541 COMPARE_NODE_FIELD(typeName);
1542 COMPARE_NODE_FIELD(params);
1543
1544 return true;
1545 }
1546
1547 static bool
_equalAlterEnumStmt(const AlterEnumStmt * a,const AlterEnumStmt * b)1548 _equalAlterEnumStmt(const AlterEnumStmt *a, const AlterEnumStmt *b)
1549 {
1550 COMPARE_NODE_FIELD(typeName);
1551 COMPARE_STRING_FIELD(oldVal);
1552 COMPARE_STRING_FIELD(newVal);
1553 COMPARE_STRING_FIELD(newValNeighbor);
1554 COMPARE_SCALAR_FIELD(newValIsAfter);
1555 COMPARE_SCALAR_FIELD(skipIfNewValExists);
1556
1557 return true;
1558 }
1559
1560 static bool
_equalViewStmt(const ViewStmt * a,const ViewStmt * b)1561 _equalViewStmt(const ViewStmt *a, const ViewStmt *b)
1562 {
1563 COMPARE_NODE_FIELD(view);
1564 COMPARE_NODE_FIELD(aliases);
1565 COMPARE_NODE_FIELD(query);
1566 COMPARE_SCALAR_FIELD(replace);
1567 COMPARE_NODE_FIELD(options);
1568 COMPARE_SCALAR_FIELD(withCheckOption);
1569
1570 return true;
1571 }
1572
1573 static bool
_equalLoadStmt(const LoadStmt * a,const LoadStmt * b)1574 _equalLoadStmt(const LoadStmt *a, const LoadStmt *b)
1575 {
1576 COMPARE_STRING_FIELD(filename);
1577
1578 return true;
1579 }
1580
1581 static bool
_equalCreateDomainStmt(const CreateDomainStmt * a,const CreateDomainStmt * b)1582 _equalCreateDomainStmt(const CreateDomainStmt *a, const CreateDomainStmt *b)
1583 {
1584 COMPARE_NODE_FIELD(domainname);
1585 COMPARE_NODE_FIELD(typeName);
1586 COMPARE_NODE_FIELD(collClause);
1587 COMPARE_NODE_FIELD(constraints);
1588
1589 return true;
1590 }
1591
1592 static bool
_equalCreateOpClassStmt(const CreateOpClassStmt * a,const CreateOpClassStmt * b)1593 _equalCreateOpClassStmt(const CreateOpClassStmt *a, const CreateOpClassStmt *b)
1594 {
1595 COMPARE_NODE_FIELD(opclassname);
1596 COMPARE_NODE_FIELD(opfamilyname);
1597 COMPARE_STRING_FIELD(amname);
1598 COMPARE_NODE_FIELD(datatype);
1599 COMPARE_NODE_FIELD(items);
1600 COMPARE_SCALAR_FIELD(isDefault);
1601
1602 return true;
1603 }
1604
1605 static bool
_equalCreateOpClassItem(const CreateOpClassItem * a,const CreateOpClassItem * b)1606 _equalCreateOpClassItem(const CreateOpClassItem *a, const CreateOpClassItem *b)
1607 {
1608 COMPARE_SCALAR_FIELD(itemtype);
1609 COMPARE_NODE_FIELD(name);
1610 COMPARE_SCALAR_FIELD(number);
1611 COMPARE_NODE_FIELD(order_family);
1612 COMPARE_NODE_FIELD(class_args);
1613 COMPARE_NODE_FIELD(storedtype);
1614
1615 return true;
1616 }
1617
1618 static bool
_equalCreateOpFamilyStmt(const CreateOpFamilyStmt * a,const CreateOpFamilyStmt * b)1619 _equalCreateOpFamilyStmt(const CreateOpFamilyStmt *a, const CreateOpFamilyStmt *b)
1620 {
1621 COMPARE_NODE_FIELD(opfamilyname);
1622 COMPARE_STRING_FIELD(amname);
1623
1624 return true;
1625 }
1626
1627 static bool
_equalAlterOpFamilyStmt(const AlterOpFamilyStmt * a,const AlterOpFamilyStmt * b)1628 _equalAlterOpFamilyStmt(const AlterOpFamilyStmt *a, const AlterOpFamilyStmt *b)
1629 {
1630 COMPARE_NODE_FIELD(opfamilyname);
1631 COMPARE_STRING_FIELD(amname);
1632 COMPARE_SCALAR_FIELD(isDrop);
1633 COMPARE_NODE_FIELD(items);
1634
1635 return true;
1636 }
1637
1638 static bool
_equalCreatedbStmt(const CreatedbStmt * a,const CreatedbStmt * b)1639 _equalCreatedbStmt(const CreatedbStmt *a, const CreatedbStmt *b)
1640 {
1641 COMPARE_STRING_FIELD(dbname);
1642 COMPARE_NODE_FIELD(options);
1643
1644 return true;
1645 }
1646
1647 static bool
_equalAlterDatabaseStmt(const AlterDatabaseStmt * a,const AlterDatabaseStmt * b)1648 _equalAlterDatabaseStmt(const AlterDatabaseStmt *a, const AlterDatabaseStmt *b)
1649 {
1650 COMPARE_STRING_FIELD(dbname);
1651 COMPARE_NODE_FIELD(options);
1652
1653 return true;
1654 }
1655
1656 static bool
_equalAlterDatabaseSetStmt(const AlterDatabaseSetStmt * a,const AlterDatabaseSetStmt * b)1657 _equalAlterDatabaseSetStmt(const AlterDatabaseSetStmt *a, const AlterDatabaseSetStmt *b)
1658 {
1659 COMPARE_STRING_FIELD(dbname);
1660 COMPARE_NODE_FIELD(setstmt);
1661
1662 return true;
1663 }
1664
1665 static bool
_equalDropdbStmt(const DropdbStmt * a,const DropdbStmt * b)1666 _equalDropdbStmt(const DropdbStmt *a, const DropdbStmt *b)
1667 {
1668 COMPARE_STRING_FIELD(dbname);
1669 COMPARE_SCALAR_FIELD(missing_ok);
1670
1671 return true;
1672 }
1673
1674 static bool
_equalVacuumStmt(const VacuumStmt * a,const VacuumStmt * b)1675 _equalVacuumStmt(const VacuumStmt *a, const VacuumStmt *b)
1676 {
1677 COMPARE_NODE_FIELD(options);
1678 COMPARE_NODE_FIELD(rels);
1679 COMPARE_SCALAR_FIELD(is_vacuumcmd);
1680
1681 return true;
1682 }
1683
1684 static bool
_equalVacuumRelation(const VacuumRelation * a,const VacuumRelation * b)1685 _equalVacuumRelation(const VacuumRelation *a, const VacuumRelation *b)
1686 {
1687 COMPARE_NODE_FIELD(relation);
1688 COMPARE_SCALAR_FIELD(oid);
1689 COMPARE_NODE_FIELD(va_cols);
1690
1691 return true;
1692 }
1693
1694 static bool
_equalExplainStmt(const ExplainStmt * a,const ExplainStmt * b)1695 _equalExplainStmt(const ExplainStmt *a, const ExplainStmt *b)
1696 {
1697 COMPARE_NODE_FIELD(query);
1698 COMPARE_NODE_FIELD(options);
1699
1700 return true;
1701 }
1702
1703 static bool
_equalCreateTableAsStmt(const CreateTableAsStmt * a,const CreateTableAsStmt * b)1704 _equalCreateTableAsStmt(const CreateTableAsStmt *a, const CreateTableAsStmt *b)
1705 {
1706 COMPARE_NODE_FIELD(query);
1707 COMPARE_NODE_FIELD(into);
1708 COMPARE_SCALAR_FIELD(relkind);
1709 COMPARE_SCALAR_FIELD(is_select_into);
1710 COMPARE_SCALAR_FIELD(if_not_exists);
1711
1712 return true;
1713 }
1714
1715 static bool
_equalRefreshMatViewStmt(const RefreshMatViewStmt * a,const RefreshMatViewStmt * b)1716 _equalRefreshMatViewStmt(const RefreshMatViewStmt *a, const RefreshMatViewStmt *b)
1717 {
1718 COMPARE_SCALAR_FIELD(concurrent);
1719 COMPARE_SCALAR_FIELD(skipData);
1720 COMPARE_NODE_FIELD(relation);
1721
1722 return true;
1723 }
1724
1725 static bool
_equalReplicaIdentityStmt(const ReplicaIdentityStmt * a,const ReplicaIdentityStmt * b)1726 _equalReplicaIdentityStmt(const ReplicaIdentityStmt *a, const ReplicaIdentityStmt *b)
1727 {
1728 COMPARE_SCALAR_FIELD(identity_type);
1729 COMPARE_STRING_FIELD(name);
1730
1731 return true;
1732 }
1733
1734 static bool
_equalAlterSystemStmt(const AlterSystemStmt * a,const AlterSystemStmt * b)1735 _equalAlterSystemStmt(const AlterSystemStmt *a, const AlterSystemStmt *b)
1736 {
1737 COMPARE_NODE_FIELD(setstmt);
1738
1739 return true;
1740 }
1741
1742
1743 static bool
_equalCreateSeqStmt(const CreateSeqStmt * a,const CreateSeqStmt * b)1744 _equalCreateSeqStmt(const CreateSeqStmt *a, const CreateSeqStmt *b)
1745 {
1746 COMPARE_NODE_FIELD(sequence);
1747 COMPARE_NODE_FIELD(options);
1748 COMPARE_SCALAR_FIELD(ownerId);
1749 COMPARE_SCALAR_FIELD(for_identity);
1750 COMPARE_SCALAR_FIELD(if_not_exists);
1751
1752 return true;
1753 }
1754
1755 static bool
_equalAlterSeqStmt(const AlterSeqStmt * a,const AlterSeqStmt * b)1756 _equalAlterSeqStmt(const AlterSeqStmt *a, const AlterSeqStmt *b)
1757 {
1758 COMPARE_NODE_FIELD(sequence);
1759 COMPARE_NODE_FIELD(options);
1760 COMPARE_SCALAR_FIELD(for_identity);
1761 COMPARE_SCALAR_FIELD(missing_ok);
1762
1763 return true;
1764 }
1765
1766 static bool
_equalVariableSetStmt(const VariableSetStmt * a,const VariableSetStmt * b)1767 _equalVariableSetStmt(const VariableSetStmt *a, const VariableSetStmt *b)
1768 {
1769 COMPARE_SCALAR_FIELD(kind);
1770 COMPARE_STRING_FIELD(name);
1771 COMPARE_NODE_FIELD(args);
1772 COMPARE_SCALAR_FIELD(is_local);
1773
1774 return true;
1775 }
1776
1777 static bool
_equalVariableShowStmt(const VariableShowStmt * a,const VariableShowStmt * b)1778 _equalVariableShowStmt(const VariableShowStmt *a, const VariableShowStmt *b)
1779 {
1780 COMPARE_STRING_FIELD(name);
1781
1782 return true;
1783 }
1784
1785 static bool
_equalDiscardStmt(const DiscardStmt * a,const DiscardStmt * b)1786 _equalDiscardStmt(const DiscardStmt *a, const DiscardStmt *b)
1787 {
1788 COMPARE_SCALAR_FIELD(target);
1789
1790 return true;
1791 }
1792
1793 static bool
_equalCreateTableSpaceStmt(const CreateTableSpaceStmt * a,const CreateTableSpaceStmt * b)1794 _equalCreateTableSpaceStmt(const CreateTableSpaceStmt *a, const CreateTableSpaceStmt *b)
1795 {
1796 COMPARE_STRING_FIELD(tablespacename);
1797 COMPARE_NODE_FIELD(owner);
1798 COMPARE_STRING_FIELD(location);
1799 COMPARE_NODE_FIELD(options);
1800
1801 return true;
1802 }
1803
1804 static bool
_equalDropTableSpaceStmt(const DropTableSpaceStmt * a,const DropTableSpaceStmt * b)1805 _equalDropTableSpaceStmt(const DropTableSpaceStmt *a, const DropTableSpaceStmt *b)
1806 {
1807 COMPARE_STRING_FIELD(tablespacename);
1808 COMPARE_SCALAR_FIELD(missing_ok);
1809
1810 return true;
1811 }
1812
1813 static bool
_equalAlterTableSpaceOptionsStmt(const AlterTableSpaceOptionsStmt * a,const AlterTableSpaceOptionsStmt * b)1814 _equalAlterTableSpaceOptionsStmt(const AlterTableSpaceOptionsStmt *a,
1815 const AlterTableSpaceOptionsStmt *b)
1816 {
1817 COMPARE_STRING_FIELD(tablespacename);
1818 COMPARE_NODE_FIELD(options);
1819 COMPARE_SCALAR_FIELD(isReset);
1820
1821 return true;
1822 }
1823
1824 static bool
_equalAlterTableMoveAllStmt(const AlterTableMoveAllStmt * a,const AlterTableMoveAllStmt * b)1825 _equalAlterTableMoveAllStmt(const AlterTableMoveAllStmt *a,
1826 const AlterTableMoveAllStmt *b)
1827 {
1828 COMPARE_STRING_FIELD(orig_tablespacename);
1829 COMPARE_SCALAR_FIELD(objtype);
1830 COMPARE_NODE_FIELD(roles);
1831 COMPARE_STRING_FIELD(new_tablespacename);
1832 COMPARE_SCALAR_FIELD(nowait);
1833
1834 return true;
1835 }
1836
1837 static bool
_equalCreateExtensionStmt(const CreateExtensionStmt * a,const CreateExtensionStmt * b)1838 _equalCreateExtensionStmt(const CreateExtensionStmt *a, const CreateExtensionStmt *b)
1839 {
1840 COMPARE_STRING_FIELD(extname);
1841 COMPARE_SCALAR_FIELD(if_not_exists);
1842 COMPARE_NODE_FIELD(options);
1843
1844 return true;
1845 }
1846
1847 static bool
_equalAlterExtensionStmt(const AlterExtensionStmt * a,const AlterExtensionStmt * b)1848 _equalAlterExtensionStmt(const AlterExtensionStmt *a, const AlterExtensionStmt *b)
1849 {
1850 COMPARE_STRING_FIELD(extname);
1851 COMPARE_NODE_FIELD(options);
1852
1853 return true;
1854 }
1855
1856 static bool
_equalAlterExtensionContentsStmt(const AlterExtensionContentsStmt * a,const AlterExtensionContentsStmt * b)1857 _equalAlterExtensionContentsStmt(const AlterExtensionContentsStmt *a, const AlterExtensionContentsStmt *b)
1858 {
1859 COMPARE_STRING_FIELD(extname);
1860 COMPARE_SCALAR_FIELD(action);
1861 COMPARE_SCALAR_FIELD(objtype);
1862 COMPARE_NODE_FIELD(object);
1863
1864 return true;
1865 }
1866
1867 static bool
_equalCreateFdwStmt(const CreateFdwStmt * a,const CreateFdwStmt * b)1868 _equalCreateFdwStmt(const CreateFdwStmt *a, const CreateFdwStmt *b)
1869 {
1870 COMPARE_STRING_FIELD(fdwname);
1871 COMPARE_NODE_FIELD(func_options);
1872 COMPARE_NODE_FIELD(options);
1873
1874 return true;
1875 }
1876
1877 static bool
_equalAlterFdwStmt(const AlterFdwStmt * a,const AlterFdwStmt * b)1878 _equalAlterFdwStmt(const AlterFdwStmt *a, const AlterFdwStmt *b)
1879 {
1880 COMPARE_STRING_FIELD(fdwname);
1881 COMPARE_NODE_FIELD(func_options);
1882 COMPARE_NODE_FIELD(options);
1883
1884 return true;
1885 }
1886
1887 static bool
_equalCreateForeignServerStmt(const CreateForeignServerStmt * a,const CreateForeignServerStmt * b)1888 _equalCreateForeignServerStmt(const CreateForeignServerStmt *a, const CreateForeignServerStmt *b)
1889 {
1890 COMPARE_STRING_FIELD(servername);
1891 COMPARE_STRING_FIELD(servertype);
1892 COMPARE_STRING_FIELD(version);
1893 COMPARE_STRING_FIELD(fdwname);
1894 COMPARE_SCALAR_FIELD(if_not_exists);
1895 COMPARE_NODE_FIELD(options);
1896
1897 return true;
1898 }
1899
1900 static bool
_equalAlterForeignServerStmt(const AlterForeignServerStmt * a,const AlterForeignServerStmt * b)1901 _equalAlterForeignServerStmt(const AlterForeignServerStmt *a, const AlterForeignServerStmt *b)
1902 {
1903 COMPARE_STRING_FIELD(servername);
1904 COMPARE_STRING_FIELD(version);
1905 COMPARE_NODE_FIELD(options);
1906 COMPARE_SCALAR_FIELD(has_version);
1907
1908 return true;
1909 }
1910
1911 static bool
_equalCreateUserMappingStmt(const CreateUserMappingStmt * a,const CreateUserMappingStmt * b)1912 _equalCreateUserMappingStmt(const CreateUserMappingStmt *a, const CreateUserMappingStmt *b)
1913 {
1914 COMPARE_NODE_FIELD(user);
1915 COMPARE_STRING_FIELD(servername);
1916 COMPARE_SCALAR_FIELD(if_not_exists);
1917 COMPARE_NODE_FIELD(options);
1918
1919 return true;
1920 }
1921
1922 static bool
_equalAlterUserMappingStmt(const AlterUserMappingStmt * a,const AlterUserMappingStmt * b)1923 _equalAlterUserMappingStmt(const AlterUserMappingStmt *a, const AlterUserMappingStmt *b)
1924 {
1925 COMPARE_NODE_FIELD(user);
1926 COMPARE_STRING_FIELD(servername);
1927 COMPARE_NODE_FIELD(options);
1928
1929 return true;
1930 }
1931
1932 static bool
_equalDropUserMappingStmt(const DropUserMappingStmt * a,const DropUserMappingStmt * b)1933 _equalDropUserMappingStmt(const DropUserMappingStmt *a, const DropUserMappingStmt *b)
1934 {
1935 COMPARE_NODE_FIELD(user);
1936 COMPARE_STRING_FIELD(servername);
1937 COMPARE_SCALAR_FIELD(missing_ok);
1938
1939 return true;
1940 }
1941
1942 static bool
_equalCreateForeignTableStmt(const CreateForeignTableStmt * a,const CreateForeignTableStmt * b)1943 _equalCreateForeignTableStmt(const CreateForeignTableStmt *a, const CreateForeignTableStmt *b)
1944 {
1945 if (!_equalCreateStmt(&a->base, &b->base))
1946 return false;
1947
1948 COMPARE_STRING_FIELD(servername);
1949 COMPARE_NODE_FIELD(options);
1950
1951 return true;
1952 }
1953
1954 static bool
_equalImportForeignSchemaStmt(const ImportForeignSchemaStmt * a,const ImportForeignSchemaStmt * b)1955 _equalImportForeignSchemaStmt(const ImportForeignSchemaStmt *a, const ImportForeignSchemaStmt *b)
1956 {
1957 COMPARE_STRING_FIELD(server_name);
1958 COMPARE_STRING_FIELD(remote_schema);
1959 COMPARE_STRING_FIELD(local_schema);
1960 COMPARE_SCALAR_FIELD(list_type);
1961 COMPARE_NODE_FIELD(table_list);
1962 COMPARE_NODE_FIELD(options);
1963
1964 return true;
1965 }
1966
1967 static bool
_equalCreateTransformStmt(const CreateTransformStmt * a,const CreateTransformStmt * b)1968 _equalCreateTransformStmt(const CreateTransformStmt *a, const CreateTransformStmt *b)
1969 {
1970 COMPARE_SCALAR_FIELD(replace);
1971 COMPARE_NODE_FIELD(type_name);
1972 COMPARE_STRING_FIELD(lang);
1973 COMPARE_NODE_FIELD(fromsql);
1974 COMPARE_NODE_FIELD(tosql);
1975
1976 return true;
1977 }
1978
1979 static bool
_equalCreateAmStmt(const CreateAmStmt * a,const CreateAmStmt * b)1980 _equalCreateAmStmt(const CreateAmStmt *a, const CreateAmStmt *b)
1981 {
1982 COMPARE_STRING_FIELD(amname);
1983 COMPARE_NODE_FIELD(handler_name);
1984 COMPARE_SCALAR_FIELD(amtype);
1985
1986 return true;
1987 }
1988
1989 static bool
_equalCreateTrigStmt(const CreateTrigStmt * a,const CreateTrigStmt * b)1990 _equalCreateTrigStmt(const CreateTrigStmt *a, const CreateTrigStmt *b)
1991 {
1992 COMPARE_STRING_FIELD(trigname);
1993 COMPARE_NODE_FIELD(relation);
1994 COMPARE_NODE_FIELD(funcname);
1995 COMPARE_NODE_FIELD(args);
1996 COMPARE_SCALAR_FIELD(row);
1997 COMPARE_SCALAR_FIELD(timing);
1998 COMPARE_SCALAR_FIELD(events);
1999 COMPARE_NODE_FIELD(columns);
2000 COMPARE_NODE_FIELD(whenClause);
2001 COMPARE_SCALAR_FIELD(isconstraint);
2002 COMPARE_NODE_FIELD(transitionRels);
2003 COMPARE_SCALAR_FIELD(deferrable);
2004 COMPARE_SCALAR_FIELD(initdeferred);
2005 COMPARE_NODE_FIELD(constrrel);
2006
2007 return true;
2008 }
2009
2010 static bool
_equalCreateEventTrigStmt(const CreateEventTrigStmt * a,const CreateEventTrigStmt * b)2011 _equalCreateEventTrigStmt(const CreateEventTrigStmt *a, const CreateEventTrigStmt *b)
2012 {
2013 COMPARE_STRING_FIELD(trigname);
2014 COMPARE_STRING_FIELD(eventname);
2015 COMPARE_NODE_FIELD(whenclause);
2016 COMPARE_NODE_FIELD(funcname);
2017
2018 return true;
2019 }
2020
2021 static bool
_equalAlterEventTrigStmt(const AlterEventTrigStmt * a,const AlterEventTrigStmt * b)2022 _equalAlterEventTrigStmt(const AlterEventTrigStmt *a, const AlterEventTrigStmt *b)
2023 {
2024 COMPARE_STRING_FIELD(trigname);
2025 COMPARE_SCALAR_FIELD(tgenabled);
2026
2027 return true;
2028 }
2029
2030 static bool
_equalCreatePLangStmt(const CreatePLangStmt * a,const CreatePLangStmt * b)2031 _equalCreatePLangStmt(const CreatePLangStmt *a, const CreatePLangStmt *b)
2032 {
2033 COMPARE_SCALAR_FIELD(replace);
2034 COMPARE_STRING_FIELD(plname);
2035 COMPARE_NODE_FIELD(plhandler);
2036 COMPARE_NODE_FIELD(plinline);
2037 COMPARE_NODE_FIELD(plvalidator);
2038 COMPARE_SCALAR_FIELD(pltrusted);
2039
2040 return true;
2041 }
2042
2043 static bool
_equalCreateRoleStmt(const CreateRoleStmt * a,const CreateRoleStmt * b)2044 _equalCreateRoleStmt(const CreateRoleStmt *a, const CreateRoleStmt *b)
2045 {
2046 COMPARE_SCALAR_FIELD(stmt_type);
2047 COMPARE_STRING_FIELD(role);
2048 COMPARE_NODE_FIELD(options);
2049
2050 return true;
2051 }
2052
2053 static bool
_equalAlterRoleStmt(const AlterRoleStmt * a,const AlterRoleStmt * b)2054 _equalAlterRoleStmt(const AlterRoleStmt *a, const AlterRoleStmt *b)
2055 {
2056 COMPARE_NODE_FIELD(role);
2057 COMPARE_NODE_FIELD(options);
2058 COMPARE_SCALAR_FIELD(action);
2059
2060 return true;
2061 }
2062
2063 static bool
_equalAlterRoleSetStmt(const AlterRoleSetStmt * a,const AlterRoleSetStmt * b)2064 _equalAlterRoleSetStmt(const AlterRoleSetStmt *a, const AlterRoleSetStmt *b)
2065 {
2066 COMPARE_NODE_FIELD(role);
2067 COMPARE_STRING_FIELD(database);
2068 COMPARE_NODE_FIELD(setstmt);
2069
2070 return true;
2071 }
2072
2073 static bool
_equalDropRoleStmt(const DropRoleStmt * a,const DropRoleStmt * b)2074 _equalDropRoleStmt(const DropRoleStmt *a, const DropRoleStmt *b)
2075 {
2076 COMPARE_NODE_FIELD(roles);
2077 COMPARE_SCALAR_FIELD(missing_ok);
2078
2079 return true;
2080 }
2081
2082 static bool
_equalLockStmt(const LockStmt * a,const LockStmt * b)2083 _equalLockStmt(const LockStmt *a, const LockStmt *b)
2084 {
2085 COMPARE_NODE_FIELD(relations);
2086 COMPARE_SCALAR_FIELD(mode);
2087 COMPARE_SCALAR_FIELD(nowait);
2088
2089 return true;
2090 }
2091
2092 static bool
_equalConstraintsSetStmt(const ConstraintsSetStmt * a,const ConstraintsSetStmt * b)2093 _equalConstraintsSetStmt(const ConstraintsSetStmt *a, const ConstraintsSetStmt *b)
2094 {
2095 COMPARE_NODE_FIELD(constraints);
2096 COMPARE_SCALAR_FIELD(deferred);
2097
2098 return true;
2099 }
2100
2101 static bool
_equalReindexStmt(const ReindexStmt * a,const ReindexStmt * b)2102 _equalReindexStmt(const ReindexStmt *a, const ReindexStmt *b)
2103 {
2104 COMPARE_SCALAR_FIELD(kind);
2105 COMPARE_NODE_FIELD(relation);
2106 COMPARE_STRING_FIELD(name);
2107 COMPARE_SCALAR_FIELD(options);
2108 COMPARE_SCALAR_FIELD(concurrent);
2109
2110 return true;
2111 }
2112
2113 static bool
_equalCreateSchemaStmt(const CreateSchemaStmt * a,const CreateSchemaStmt * b)2114 _equalCreateSchemaStmt(const CreateSchemaStmt *a, const CreateSchemaStmt *b)
2115 {
2116 COMPARE_STRING_FIELD(schemaname);
2117 COMPARE_NODE_FIELD(authrole);
2118 COMPARE_NODE_FIELD(schemaElts);
2119 COMPARE_SCALAR_FIELD(if_not_exists);
2120
2121 return true;
2122 }
2123
2124 static bool
_equalCreateConversionStmt(const CreateConversionStmt * a,const CreateConversionStmt * b)2125 _equalCreateConversionStmt(const CreateConversionStmt *a, const CreateConversionStmt *b)
2126 {
2127 COMPARE_NODE_FIELD(conversion_name);
2128 COMPARE_STRING_FIELD(for_encoding_name);
2129 COMPARE_STRING_FIELD(to_encoding_name);
2130 COMPARE_NODE_FIELD(func_name);
2131 COMPARE_SCALAR_FIELD(def);
2132
2133 return true;
2134 }
2135
2136 static bool
_equalCreateCastStmt(const CreateCastStmt * a,const CreateCastStmt * b)2137 _equalCreateCastStmt(const CreateCastStmt *a, const CreateCastStmt *b)
2138 {
2139 COMPARE_NODE_FIELD(sourcetype);
2140 COMPARE_NODE_FIELD(targettype);
2141 COMPARE_NODE_FIELD(func);
2142 COMPARE_SCALAR_FIELD(context);
2143 COMPARE_SCALAR_FIELD(inout);
2144
2145 return true;
2146 }
2147
2148 static bool
_equalPrepareStmt(const PrepareStmt * a,const PrepareStmt * b)2149 _equalPrepareStmt(const PrepareStmt *a, const PrepareStmt *b)
2150 {
2151 COMPARE_STRING_FIELD(name);
2152 COMPARE_NODE_FIELD(argtypes);
2153 COMPARE_NODE_FIELD(query);
2154
2155 return true;
2156 }
2157
2158 static bool
_equalExecuteStmt(const ExecuteStmt * a,const ExecuteStmt * b)2159 _equalExecuteStmt(const ExecuteStmt *a, const ExecuteStmt *b)
2160 {
2161 COMPARE_STRING_FIELD(name);
2162 COMPARE_NODE_FIELD(params);
2163
2164 return true;
2165 }
2166
2167 static bool
_equalDeallocateStmt(const DeallocateStmt * a,const DeallocateStmt * b)2168 _equalDeallocateStmt(const DeallocateStmt *a, const DeallocateStmt *b)
2169 {
2170 COMPARE_STRING_FIELD(name);
2171
2172 return true;
2173 }
2174
2175 static bool
_equalDropOwnedStmt(const DropOwnedStmt * a,const DropOwnedStmt * b)2176 _equalDropOwnedStmt(const DropOwnedStmt *a, const DropOwnedStmt *b)
2177 {
2178 COMPARE_NODE_FIELD(roles);
2179 COMPARE_SCALAR_FIELD(behavior);
2180
2181 return true;
2182 }
2183
2184 static bool
_equalReassignOwnedStmt(const ReassignOwnedStmt * a,const ReassignOwnedStmt * b)2185 _equalReassignOwnedStmt(const ReassignOwnedStmt *a, const ReassignOwnedStmt *b)
2186 {
2187 COMPARE_NODE_FIELD(roles);
2188 COMPARE_NODE_FIELD(newrole);
2189
2190 return true;
2191 }
2192
2193 static bool
_equalAlterTSDictionaryStmt(const AlterTSDictionaryStmt * a,const AlterTSDictionaryStmt * b)2194 _equalAlterTSDictionaryStmt(const AlterTSDictionaryStmt *a, const AlterTSDictionaryStmt *b)
2195 {
2196 COMPARE_NODE_FIELD(dictname);
2197 COMPARE_NODE_FIELD(options);
2198
2199 return true;
2200 }
2201
2202 static bool
_equalAlterTSConfigurationStmt(const AlterTSConfigurationStmt * a,const AlterTSConfigurationStmt * b)2203 _equalAlterTSConfigurationStmt(const AlterTSConfigurationStmt *a,
2204 const AlterTSConfigurationStmt *b)
2205 {
2206 COMPARE_SCALAR_FIELD(kind);
2207 COMPARE_NODE_FIELD(cfgname);
2208 COMPARE_NODE_FIELD(tokentype);
2209 COMPARE_NODE_FIELD(dicts);
2210 COMPARE_SCALAR_FIELD(override);
2211 COMPARE_SCALAR_FIELD(replace);
2212 COMPARE_SCALAR_FIELD(missing_ok);
2213
2214 return true;
2215 }
2216
2217 static bool
_equalCreatePublicationStmt(const CreatePublicationStmt * a,const CreatePublicationStmt * b)2218 _equalCreatePublicationStmt(const CreatePublicationStmt *a,
2219 const CreatePublicationStmt *b)
2220 {
2221 COMPARE_STRING_FIELD(pubname);
2222 COMPARE_NODE_FIELD(options);
2223 COMPARE_NODE_FIELD(tables);
2224 COMPARE_SCALAR_FIELD(for_all_tables);
2225
2226 return true;
2227 }
2228
2229 static bool
_equalAlterPublicationStmt(const AlterPublicationStmt * a,const AlterPublicationStmt * b)2230 _equalAlterPublicationStmt(const AlterPublicationStmt *a,
2231 const AlterPublicationStmt *b)
2232 {
2233 COMPARE_STRING_FIELD(pubname);
2234 COMPARE_NODE_FIELD(options);
2235 COMPARE_NODE_FIELD(tables);
2236 COMPARE_SCALAR_FIELD(for_all_tables);
2237 COMPARE_SCALAR_FIELD(tableAction);
2238
2239 return true;
2240 }
2241
2242 static bool
_equalCreateSubscriptionStmt(const CreateSubscriptionStmt * a,const CreateSubscriptionStmt * b)2243 _equalCreateSubscriptionStmt(const CreateSubscriptionStmt *a,
2244 const CreateSubscriptionStmt *b)
2245 {
2246 COMPARE_STRING_FIELD(subname);
2247 COMPARE_STRING_FIELD(conninfo);
2248 COMPARE_NODE_FIELD(publication);
2249 COMPARE_NODE_FIELD(options);
2250
2251 return true;
2252 }
2253
2254 static bool
_equalAlterSubscriptionStmt(const AlterSubscriptionStmt * a,const AlterSubscriptionStmt * b)2255 _equalAlterSubscriptionStmt(const AlterSubscriptionStmt *a,
2256 const AlterSubscriptionStmt *b)
2257 {
2258 COMPARE_SCALAR_FIELD(kind);
2259 COMPARE_STRING_FIELD(subname);
2260 COMPARE_STRING_FIELD(conninfo);
2261 COMPARE_NODE_FIELD(publication);
2262 COMPARE_NODE_FIELD(options);
2263
2264 return true;
2265 }
2266
2267 static bool
_equalDropSubscriptionStmt(const DropSubscriptionStmt * a,const DropSubscriptionStmt * b)2268 _equalDropSubscriptionStmt(const DropSubscriptionStmt *a,
2269 const DropSubscriptionStmt *b)
2270 {
2271 COMPARE_STRING_FIELD(subname);
2272 COMPARE_SCALAR_FIELD(missing_ok);
2273 COMPARE_SCALAR_FIELD(behavior);
2274
2275 return true;
2276 }
2277
2278 static bool
_equalCreatePolicyStmt(const CreatePolicyStmt * a,const CreatePolicyStmt * b)2279 _equalCreatePolicyStmt(const CreatePolicyStmt *a, const CreatePolicyStmt *b)
2280 {
2281 COMPARE_STRING_FIELD(policy_name);
2282 COMPARE_NODE_FIELD(table);
2283 COMPARE_STRING_FIELD(cmd_name);
2284 COMPARE_SCALAR_FIELD(permissive);
2285 COMPARE_NODE_FIELD(roles);
2286 COMPARE_NODE_FIELD(qual);
2287 COMPARE_NODE_FIELD(with_check);
2288
2289 return true;
2290 }
2291
2292 static bool
_equalAlterPolicyStmt(const AlterPolicyStmt * a,const AlterPolicyStmt * b)2293 _equalAlterPolicyStmt(const AlterPolicyStmt *a, const AlterPolicyStmt *b)
2294 {
2295 COMPARE_STRING_FIELD(policy_name);
2296 COMPARE_NODE_FIELD(table);
2297 COMPARE_NODE_FIELD(roles);
2298 COMPARE_NODE_FIELD(qual);
2299 COMPARE_NODE_FIELD(with_check);
2300
2301 return true;
2302 }
2303
2304 static bool
_equalAExpr(const A_Expr * a,const A_Expr * b)2305 _equalAExpr(const A_Expr *a, const A_Expr *b)
2306 {
2307 COMPARE_SCALAR_FIELD(kind);
2308 COMPARE_NODE_FIELD(name);
2309 COMPARE_NODE_FIELD(lexpr);
2310 COMPARE_NODE_FIELD(rexpr);
2311 COMPARE_LOCATION_FIELD(location);
2312
2313 return true;
2314 }
2315
2316 static bool
_equalColumnRef(const ColumnRef * a,const ColumnRef * b)2317 _equalColumnRef(const ColumnRef *a, const ColumnRef *b)
2318 {
2319 COMPARE_NODE_FIELD(fields);
2320 COMPARE_LOCATION_FIELD(location);
2321
2322 return true;
2323 }
2324
2325 static bool
_equalParamRef(const ParamRef * a,const ParamRef * b)2326 _equalParamRef(const ParamRef *a, const ParamRef *b)
2327 {
2328 COMPARE_SCALAR_FIELD(number);
2329 COMPARE_LOCATION_FIELD(location);
2330
2331 return true;
2332 }
2333
2334 static bool
_equalAConst(const A_Const * a,const A_Const * b)2335 _equalAConst(const A_Const *a, const A_Const *b)
2336 {
2337 if (!equal(&a->val, &b->val)) /* hack for in-line Value field */
2338 return false;
2339 COMPARE_LOCATION_FIELD(location);
2340
2341 return true;
2342 }
2343
2344 static bool
_equalFuncCall(const FuncCall * a,const FuncCall * b)2345 _equalFuncCall(const FuncCall *a, const FuncCall *b)
2346 {
2347 COMPARE_NODE_FIELD(funcname);
2348 COMPARE_NODE_FIELD(args);
2349 COMPARE_NODE_FIELD(agg_order);
2350 COMPARE_NODE_FIELD(agg_filter);
2351 COMPARE_SCALAR_FIELD(agg_within_group);
2352 COMPARE_SCALAR_FIELD(agg_star);
2353 COMPARE_SCALAR_FIELD(agg_distinct);
2354 COMPARE_SCALAR_FIELD(func_variadic);
2355 COMPARE_NODE_FIELD(over);
2356 COMPARE_LOCATION_FIELD(location);
2357
2358 return true;
2359 }
2360
2361 static bool
_equalAStar(const A_Star * a,const A_Star * b)2362 _equalAStar(const A_Star *a, const A_Star *b)
2363 {
2364 return true;
2365 }
2366
2367 static bool
_equalAIndices(const A_Indices * a,const A_Indices * b)2368 _equalAIndices(const A_Indices *a, const A_Indices *b)
2369 {
2370 COMPARE_SCALAR_FIELD(is_slice);
2371 COMPARE_NODE_FIELD(lidx);
2372 COMPARE_NODE_FIELD(uidx);
2373
2374 return true;
2375 }
2376
2377 static bool
_equalA_Indirection(const A_Indirection * a,const A_Indirection * b)2378 _equalA_Indirection(const A_Indirection *a, const A_Indirection *b)
2379 {
2380 COMPARE_NODE_FIELD(arg);
2381 COMPARE_NODE_FIELD(indirection);
2382
2383 return true;
2384 }
2385
2386 static bool
_equalA_ArrayExpr(const A_ArrayExpr * a,const A_ArrayExpr * b)2387 _equalA_ArrayExpr(const A_ArrayExpr *a, const A_ArrayExpr *b)
2388 {
2389 COMPARE_NODE_FIELD(elements);
2390 COMPARE_LOCATION_FIELD(location);
2391
2392 return true;
2393 }
2394
2395 static bool
_equalResTarget(const ResTarget * a,const ResTarget * b)2396 _equalResTarget(const ResTarget *a, const ResTarget *b)
2397 {
2398 COMPARE_STRING_FIELD(name);
2399 COMPARE_NODE_FIELD(indirection);
2400 COMPARE_NODE_FIELD(val);
2401 COMPARE_LOCATION_FIELD(location);
2402
2403 return true;
2404 }
2405
2406 static bool
_equalMultiAssignRef(const MultiAssignRef * a,const MultiAssignRef * b)2407 _equalMultiAssignRef(const MultiAssignRef *a, const MultiAssignRef *b)
2408 {
2409 COMPARE_NODE_FIELD(source);
2410 COMPARE_SCALAR_FIELD(colno);
2411 COMPARE_SCALAR_FIELD(ncolumns);
2412
2413 return true;
2414 }
2415
2416 static bool
_equalTypeName(const TypeName * a,const TypeName * b)2417 _equalTypeName(const TypeName *a, const TypeName *b)
2418 {
2419 COMPARE_NODE_FIELD(names);
2420 COMPARE_SCALAR_FIELD(typeOid);
2421 COMPARE_SCALAR_FIELD(setof);
2422 COMPARE_SCALAR_FIELD(pct_type);
2423 COMPARE_NODE_FIELD(typmods);
2424 COMPARE_SCALAR_FIELD(typemod);
2425 COMPARE_NODE_FIELD(arrayBounds);
2426 COMPARE_LOCATION_FIELD(location);
2427
2428 return true;
2429 }
2430
2431 static bool
_equalTypeCast(const TypeCast * a,const TypeCast * b)2432 _equalTypeCast(const TypeCast *a, const TypeCast *b)
2433 {
2434 COMPARE_NODE_FIELD(arg);
2435 COMPARE_NODE_FIELD(typeName);
2436 COMPARE_LOCATION_FIELD(location);
2437
2438 return true;
2439 }
2440
2441 static bool
_equalCollateClause(const CollateClause * a,const CollateClause * b)2442 _equalCollateClause(const CollateClause *a, const CollateClause *b)
2443 {
2444 COMPARE_NODE_FIELD(arg);
2445 COMPARE_NODE_FIELD(collname);
2446 COMPARE_LOCATION_FIELD(location);
2447
2448 return true;
2449 }
2450
2451 static bool
_equalSortBy(const SortBy * a,const SortBy * b)2452 _equalSortBy(const SortBy *a, const SortBy *b)
2453 {
2454 COMPARE_NODE_FIELD(node);
2455 COMPARE_SCALAR_FIELD(sortby_dir);
2456 COMPARE_SCALAR_FIELD(sortby_nulls);
2457 COMPARE_NODE_FIELD(useOp);
2458 COMPARE_LOCATION_FIELD(location);
2459
2460 return true;
2461 }
2462
2463 static bool
_equalWindowDef(const WindowDef * a,const WindowDef * b)2464 _equalWindowDef(const WindowDef *a, const WindowDef *b)
2465 {
2466 COMPARE_STRING_FIELD(name);
2467 COMPARE_STRING_FIELD(refname);
2468 COMPARE_NODE_FIELD(partitionClause);
2469 COMPARE_NODE_FIELD(orderClause);
2470 COMPARE_SCALAR_FIELD(frameOptions);
2471 COMPARE_NODE_FIELD(startOffset);
2472 COMPARE_NODE_FIELD(endOffset);
2473 COMPARE_LOCATION_FIELD(location);
2474
2475 return true;
2476 }
2477
2478 static bool
_equalRangeSubselect(const RangeSubselect * a,const RangeSubselect * b)2479 _equalRangeSubselect(const RangeSubselect *a, const RangeSubselect *b)
2480 {
2481 COMPARE_SCALAR_FIELD(lateral);
2482 COMPARE_NODE_FIELD(subquery);
2483 COMPARE_NODE_FIELD(alias);
2484
2485 return true;
2486 }
2487
2488 static bool
_equalRangeFunction(const RangeFunction * a,const RangeFunction * b)2489 _equalRangeFunction(const RangeFunction *a, const RangeFunction *b)
2490 {
2491 COMPARE_SCALAR_FIELD(lateral);
2492 COMPARE_SCALAR_FIELD(ordinality);
2493 COMPARE_SCALAR_FIELD(is_rowsfrom);
2494 COMPARE_NODE_FIELD(functions);
2495 COMPARE_NODE_FIELD(alias);
2496 COMPARE_NODE_FIELD(coldeflist);
2497
2498 return true;
2499 }
2500
2501 static bool
_equalRangeTableSample(const RangeTableSample * a,const RangeTableSample * b)2502 _equalRangeTableSample(const RangeTableSample *a, const RangeTableSample *b)
2503 {
2504 COMPARE_NODE_FIELD(relation);
2505 COMPARE_NODE_FIELD(method);
2506 COMPARE_NODE_FIELD(args);
2507 COMPARE_NODE_FIELD(repeatable);
2508 COMPARE_LOCATION_FIELD(location);
2509
2510 return true;
2511 }
2512
2513 static bool
_equalRangeTableFunc(const RangeTableFunc * a,const RangeTableFunc * b)2514 _equalRangeTableFunc(const RangeTableFunc *a, const RangeTableFunc *b)
2515 {
2516 COMPARE_SCALAR_FIELD(lateral);
2517 COMPARE_NODE_FIELD(docexpr);
2518 COMPARE_NODE_FIELD(rowexpr);
2519 COMPARE_NODE_FIELD(namespaces);
2520 COMPARE_NODE_FIELD(columns);
2521 COMPARE_NODE_FIELD(alias);
2522 COMPARE_LOCATION_FIELD(location);
2523
2524 return true;
2525 }
2526
2527 static bool
_equalRangeTableFuncCol(const RangeTableFuncCol * a,const RangeTableFuncCol * b)2528 _equalRangeTableFuncCol(const RangeTableFuncCol *a, const RangeTableFuncCol *b)
2529 {
2530 COMPARE_STRING_FIELD(colname);
2531 COMPARE_NODE_FIELD(typeName);
2532 COMPARE_SCALAR_FIELD(for_ordinality);
2533 COMPARE_SCALAR_FIELD(is_not_null);
2534 COMPARE_NODE_FIELD(colexpr);
2535 COMPARE_NODE_FIELD(coldefexpr);
2536 COMPARE_LOCATION_FIELD(location);
2537
2538 return true;
2539 }
2540
2541
2542 static bool
_equalIndexElem(const IndexElem * a,const IndexElem * b)2543 _equalIndexElem(const IndexElem *a, const IndexElem *b)
2544 {
2545 COMPARE_STRING_FIELD(name);
2546 COMPARE_NODE_FIELD(expr);
2547 COMPARE_STRING_FIELD(indexcolname);
2548 COMPARE_NODE_FIELD(collation);
2549 COMPARE_NODE_FIELD(opclass);
2550 COMPARE_SCALAR_FIELD(ordering);
2551 COMPARE_SCALAR_FIELD(nulls_ordering);
2552
2553 return true;
2554 }
2555
2556 static bool
_equalColumnDef(const ColumnDef * a,const ColumnDef * b)2557 _equalColumnDef(const ColumnDef *a, const ColumnDef *b)
2558 {
2559 COMPARE_STRING_FIELD(colname);
2560 COMPARE_NODE_FIELD(typeName);
2561 COMPARE_SCALAR_FIELD(inhcount);
2562 COMPARE_SCALAR_FIELD(is_local);
2563 COMPARE_SCALAR_FIELD(is_not_null);
2564 COMPARE_SCALAR_FIELD(is_from_type);
2565 COMPARE_SCALAR_FIELD(storage);
2566 COMPARE_NODE_FIELD(raw_default);
2567 COMPARE_NODE_FIELD(cooked_default);
2568 COMPARE_SCALAR_FIELD(identity);
2569 COMPARE_NODE_FIELD(identitySequence);
2570 COMPARE_SCALAR_FIELD(generated);
2571 COMPARE_NODE_FIELD(collClause);
2572 COMPARE_SCALAR_FIELD(collOid);
2573 COMPARE_NODE_FIELD(constraints);
2574 COMPARE_NODE_FIELD(fdwoptions);
2575 COMPARE_LOCATION_FIELD(location);
2576
2577 return true;
2578 }
2579
2580 static bool
_equalConstraint(const Constraint * a,const Constraint * b)2581 _equalConstraint(const Constraint *a, const Constraint *b)
2582 {
2583 COMPARE_SCALAR_FIELD(contype);
2584 COMPARE_STRING_FIELD(conname);
2585 COMPARE_SCALAR_FIELD(deferrable);
2586 COMPARE_SCALAR_FIELD(initdeferred);
2587 COMPARE_LOCATION_FIELD(location);
2588 COMPARE_SCALAR_FIELD(is_no_inherit);
2589 COMPARE_NODE_FIELD(raw_expr);
2590 COMPARE_STRING_FIELD(cooked_expr);
2591 COMPARE_SCALAR_FIELD(generated_when);
2592 COMPARE_NODE_FIELD(keys);
2593 COMPARE_NODE_FIELD(including);
2594 COMPARE_NODE_FIELD(exclusions);
2595 COMPARE_NODE_FIELD(options);
2596 COMPARE_STRING_FIELD(indexname);
2597 COMPARE_STRING_FIELD(indexspace);
2598 COMPARE_SCALAR_FIELD(reset_default_tblspc);
2599 COMPARE_STRING_FIELD(access_method);
2600 COMPARE_NODE_FIELD(where_clause);
2601 COMPARE_NODE_FIELD(pktable);
2602 COMPARE_NODE_FIELD(fk_attrs);
2603 COMPARE_NODE_FIELD(pk_attrs);
2604 COMPARE_SCALAR_FIELD(fk_matchtype);
2605 COMPARE_SCALAR_FIELD(fk_upd_action);
2606 COMPARE_SCALAR_FIELD(fk_del_action);
2607 COMPARE_NODE_FIELD(old_conpfeqop);
2608 COMPARE_SCALAR_FIELD(old_pktable_oid);
2609 COMPARE_SCALAR_FIELD(skip_validation);
2610 COMPARE_SCALAR_FIELD(initially_valid);
2611
2612 return true;
2613 }
2614
2615 static bool
_equalDefElem(const DefElem * a,const DefElem * b)2616 _equalDefElem(const DefElem *a, const DefElem *b)
2617 {
2618 COMPARE_STRING_FIELD(defnamespace);
2619 COMPARE_STRING_FIELD(defname);
2620 COMPARE_NODE_FIELD(arg);
2621 COMPARE_SCALAR_FIELD(defaction);
2622 COMPARE_LOCATION_FIELD(location);
2623
2624 return true;
2625 }
2626
2627 static bool
_equalLockingClause(const LockingClause * a,const LockingClause * b)2628 _equalLockingClause(const LockingClause *a, const LockingClause *b)
2629 {
2630 COMPARE_NODE_FIELD(lockedRels);
2631 COMPARE_SCALAR_FIELD(strength);
2632 COMPARE_SCALAR_FIELD(waitPolicy);
2633
2634 return true;
2635 }
2636
2637 static bool
_equalRangeTblEntry(const RangeTblEntry * a,const RangeTblEntry * b)2638 _equalRangeTblEntry(const RangeTblEntry *a, const RangeTblEntry *b)
2639 {
2640 COMPARE_SCALAR_FIELD(rtekind);
2641 COMPARE_SCALAR_FIELD(relid);
2642 COMPARE_SCALAR_FIELD(relkind);
2643 COMPARE_SCALAR_FIELD(rellockmode);
2644 COMPARE_NODE_FIELD(tablesample);
2645 COMPARE_NODE_FIELD(subquery);
2646 COMPARE_SCALAR_FIELD(security_barrier);
2647 COMPARE_SCALAR_FIELD(jointype);
2648 COMPARE_NODE_FIELD(joinaliasvars);
2649 COMPARE_NODE_FIELD(functions);
2650 COMPARE_SCALAR_FIELD(funcordinality);
2651 COMPARE_NODE_FIELD(tablefunc);
2652 COMPARE_NODE_FIELD(values_lists);
2653 COMPARE_STRING_FIELD(ctename);
2654 COMPARE_SCALAR_FIELD(ctelevelsup);
2655 COMPARE_SCALAR_FIELD(self_reference);
2656 COMPARE_NODE_FIELD(coltypes);
2657 COMPARE_NODE_FIELD(coltypmods);
2658 COMPARE_NODE_FIELD(colcollations);
2659 COMPARE_STRING_FIELD(enrname);
2660 COMPARE_SCALAR_FIELD(enrtuples);
2661 COMPARE_NODE_FIELD(alias);
2662 COMPARE_NODE_FIELD(eref);
2663 COMPARE_SCALAR_FIELD(lateral);
2664 COMPARE_SCALAR_FIELD(inh);
2665 COMPARE_SCALAR_FIELD(inFromCl);
2666 COMPARE_SCALAR_FIELD(requiredPerms);
2667 COMPARE_SCALAR_FIELD(checkAsUser);
2668 COMPARE_BITMAPSET_FIELD(selectedCols);
2669 COMPARE_BITMAPSET_FIELD(insertedCols);
2670 COMPARE_BITMAPSET_FIELD(updatedCols);
2671 COMPARE_BITMAPSET_FIELD(extraUpdatedCols);
2672 COMPARE_NODE_FIELD(securityQuals);
2673
2674 return true;
2675 }
2676
2677 static bool
_equalRangeTblFunction(const RangeTblFunction * a,const RangeTblFunction * b)2678 _equalRangeTblFunction(const RangeTblFunction *a, const RangeTblFunction *b)
2679 {
2680 COMPARE_NODE_FIELD(funcexpr);
2681 COMPARE_SCALAR_FIELD(funccolcount);
2682 COMPARE_NODE_FIELD(funccolnames);
2683 COMPARE_NODE_FIELD(funccoltypes);
2684 COMPARE_NODE_FIELD(funccoltypmods);
2685 COMPARE_NODE_FIELD(funccolcollations);
2686 COMPARE_BITMAPSET_FIELD(funcparams);
2687
2688 return true;
2689 }
2690
2691 static bool
_equalTableSampleClause(const TableSampleClause * a,const TableSampleClause * b)2692 _equalTableSampleClause(const TableSampleClause *a, const TableSampleClause *b)
2693 {
2694 COMPARE_SCALAR_FIELD(tsmhandler);
2695 COMPARE_NODE_FIELD(args);
2696 COMPARE_NODE_FIELD(repeatable);
2697
2698 return true;
2699 }
2700
2701 static bool
_equalWithCheckOption(const WithCheckOption * a,const WithCheckOption * b)2702 _equalWithCheckOption(const WithCheckOption *a, const WithCheckOption *b)
2703 {
2704 COMPARE_SCALAR_FIELD(kind);
2705 COMPARE_STRING_FIELD(relname);
2706 COMPARE_STRING_FIELD(polname);
2707 COMPARE_NODE_FIELD(qual);
2708 COMPARE_SCALAR_FIELD(cascaded);
2709
2710 return true;
2711 }
2712
2713 static bool
_equalSortGroupClause(const SortGroupClause * a,const SortGroupClause * b)2714 _equalSortGroupClause(const SortGroupClause *a, const SortGroupClause *b)
2715 {
2716 COMPARE_SCALAR_FIELD(tleSortGroupRef);
2717 COMPARE_SCALAR_FIELD(eqop);
2718 COMPARE_SCALAR_FIELD(sortop);
2719 COMPARE_SCALAR_FIELD(nulls_first);
2720 COMPARE_SCALAR_FIELD(hashable);
2721
2722 return true;
2723 }
2724
2725 static bool
_equalGroupingSet(const GroupingSet * a,const GroupingSet * b)2726 _equalGroupingSet(const GroupingSet *a, const GroupingSet *b)
2727 {
2728 COMPARE_SCALAR_FIELD(kind);
2729 COMPARE_NODE_FIELD(content);
2730 COMPARE_LOCATION_FIELD(location);
2731
2732 return true;
2733 }
2734
2735 static bool
_equalWindowClause(const WindowClause * a,const WindowClause * b)2736 _equalWindowClause(const WindowClause *a, const WindowClause *b)
2737 {
2738 COMPARE_STRING_FIELD(name);
2739 COMPARE_STRING_FIELD(refname);
2740 COMPARE_NODE_FIELD(partitionClause);
2741 COMPARE_NODE_FIELD(orderClause);
2742 COMPARE_SCALAR_FIELD(frameOptions);
2743 COMPARE_NODE_FIELD(startOffset);
2744 COMPARE_NODE_FIELD(endOffset);
2745 COMPARE_SCALAR_FIELD(startInRangeFunc);
2746 COMPARE_SCALAR_FIELD(endInRangeFunc);
2747 COMPARE_SCALAR_FIELD(inRangeColl);
2748 COMPARE_SCALAR_FIELD(inRangeAsc);
2749 COMPARE_SCALAR_FIELD(inRangeNullsFirst);
2750 COMPARE_SCALAR_FIELD(winref);
2751 COMPARE_SCALAR_FIELD(copiedOrder);
2752
2753 return true;
2754 }
2755
2756 static bool
_equalRowMarkClause(const RowMarkClause * a,const RowMarkClause * b)2757 _equalRowMarkClause(const RowMarkClause *a, const RowMarkClause *b)
2758 {
2759 COMPARE_SCALAR_FIELD(rti);
2760 COMPARE_SCALAR_FIELD(strength);
2761 COMPARE_SCALAR_FIELD(waitPolicy);
2762 COMPARE_SCALAR_FIELD(pushedDown);
2763
2764 return true;
2765 }
2766
2767 static bool
_equalWithClause(const WithClause * a,const WithClause * b)2768 _equalWithClause(const WithClause *a, const WithClause *b)
2769 {
2770 COMPARE_NODE_FIELD(ctes);
2771 COMPARE_SCALAR_FIELD(recursive);
2772 COMPARE_LOCATION_FIELD(location);
2773
2774 return true;
2775 }
2776
2777 static bool
_equalInferClause(const InferClause * a,const InferClause * b)2778 _equalInferClause(const InferClause *a, const InferClause *b)
2779 {
2780 COMPARE_NODE_FIELD(indexElems);
2781 COMPARE_NODE_FIELD(whereClause);
2782 COMPARE_STRING_FIELD(conname);
2783 COMPARE_LOCATION_FIELD(location);
2784
2785 return true;
2786 }
2787
2788 static bool
_equalOnConflictClause(const OnConflictClause * a,const OnConflictClause * b)2789 _equalOnConflictClause(const OnConflictClause *a, const OnConflictClause *b)
2790 {
2791 COMPARE_SCALAR_FIELD(action);
2792 COMPARE_NODE_FIELD(infer);
2793 COMPARE_NODE_FIELD(targetList);
2794 COMPARE_NODE_FIELD(whereClause);
2795 COMPARE_LOCATION_FIELD(location);
2796
2797 return true;
2798 }
2799
2800 static bool
_equalCommonTableExpr(const CommonTableExpr * a,const CommonTableExpr * b)2801 _equalCommonTableExpr(const CommonTableExpr *a, const CommonTableExpr *b)
2802 {
2803 COMPARE_STRING_FIELD(ctename);
2804 COMPARE_NODE_FIELD(aliascolnames);
2805 COMPARE_SCALAR_FIELD(ctematerialized);
2806 COMPARE_NODE_FIELD(ctequery);
2807 COMPARE_LOCATION_FIELD(location);
2808 COMPARE_SCALAR_FIELD(cterecursive);
2809 COMPARE_SCALAR_FIELD(cterefcount);
2810 COMPARE_NODE_FIELD(ctecolnames);
2811 COMPARE_NODE_FIELD(ctecoltypes);
2812 COMPARE_NODE_FIELD(ctecoltypmods);
2813 COMPARE_NODE_FIELD(ctecolcollations);
2814
2815 return true;
2816 }
2817
2818 static bool
_equalXmlSerialize(const XmlSerialize * a,const XmlSerialize * b)2819 _equalXmlSerialize(const XmlSerialize *a, const XmlSerialize *b)
2820 {
2821 COMPARE_SCALAR_FIELD(xmloption);
2822 COMPARE_NODE_FIELD(expr);
2823 COMPARE_NODE_FIELD(typeName);
2824 COMPARE_LOCATION_FIELD(location);
2825
2826 return true;
2827 }
2828
2829 static bool
_equalRoleSpec(const RoleSpec * a,const RoleSpec * b)2830 _equalRoleSpec(const RoleSpec *a, const RoleSpec *b)
2831 {
2832 COMPARE_SCALAR_FIELD(roletype);
2833 COMPARE_STRING_FIELD(rolename);
2834 COMPARE_LOCATION_FIELD(location);
2835
2836 return true;
2837 }
2838
2839 static bool
_equalTriggerTransition(const TriggerTransition * a,const TriggerTransition * b)2840 _equalTriggerTransition(const TriggerTransition *a, const TriggerTransition *b)
2841 {
2842 COMPARE_STRING_FIELD(name);
2843 COMPARE_SCALAR_FIELD(isNew);
2844 COMPARE_SCALAR_FIELD(isTable);
2845
2846 return true;
2847 }
2848
2849 static bool
_equalPartitionElem(const PartitionElem * a,const PartitionElem * b)2850 _equalPartitionElem(const PartitionElem *a, const PartitionElem *b)
2851 {
2852 COMPARE_STRING_FIELD(name);
2853 COMPARE_NODE_FIELD(expr);
2854 COMPARE_NODE_FIELD(collation);
2855 COMPARE_NODE_FIELD(opclass);
2856 COMPARE_LOCATION_FIELD(location);
2857
2858 return true;
2859 }
2860
2861 static bool
_equalPartitionSpec(const PartitionSpec * a,const PartitionSpec * b)2862 _equalPartitionSpec(const PartitionSpec *a, const PartitionSpec *b)
2863 {
2864 COMPARE_STRING_FIELD(strategy);
2865 COMPARE_NODE_FIELD(partParams);
2866 COMPARE_LOCATION_FIELD(location);
2867
2868 return true;
2869 }
2870
2871 static bool
_equalPartitionBoundSpec(const PartitionBoundSpec * a,const PartitionBoundSpec * b)2872 _equalPartitionBoundSpec(const PartitionBoundSpec *a, const PartitionBoundSpec *b)
2873 {
2874 COMPARE_SCALAR_FIELD(strategy);
2875 COMPARE_SCALAR_FIELD(is_default);
2876 COMPARE_SCALAR_FIELD(modulus);
2877 COMPARE_SCALAR_FIELD(remainder);
2878 COMPARE_NODE_FIELD(listdatums);
2879 COMPARE_NODE_FIELD(lowerdatums);
2880 COMPARE_NODE_FIELD(upperdatums);
2881 COMPARE_LOCATION_FIELD(location);
2882
2883 return true;
2884 }
2885
2886 static bool
_equalPartitionRangeDatum(const PartitionRangeDatum * a,const PartitionRangeDatum * b)2887 _equalPartitionRangeDatum(const PartitionRangeDatum *a, const PartitionRangeDatum *b)
2888 {
2889 COMPARE_SCALAR_FIELD(kind);
2890 COMPARE_NODE_FIELD(value);
2891 COMPARE_LOCATION_FIELD(location);
2892
2893 return true;
2894 }
2895
2896 static bool
_equalPartitionCmd(const PartitionCmd * a,const PartitionCmd * b)2897 _equalPartitionCmd(const PartitionCmd *a, const PartitionCmd *b)
2898 {
2899 COMPARE_NODE_FIELD(name);
2900 COMPARE_NODE_FIELD(bound);
2901
2902 return true;
2903 }
2904
2905 /*
2906 * Stuff from pg_list.h
2907 */
2908
2909 static bool
_equalList(const List * a,const List * b)2910 _equalList(const List *a, const List *b)
2911 {
2912 const ListCell *item_a;
2913 const ListCell *item_b;
2914
2915 /*
2916 * Try to reject by simple scalar checks before grovelling through all the
2917 * list elements...
2918 */
2919 COMPARE_SCALAR_FIELD(type);
2920 COMPARE_SCALAR_FIELD(length);
2921
2922 /*
2923 * We place the switch outside the loop for the sake of efficiency; this
2924 * may not be worth doing...
2925 */
2926 switch (a->type)
2927 {
2928 case T_List:
2929 forboth(item_a, a, item_b, b)
2930 {
2931 if (!equal(lfirst(item_a), lfirst(item_b)))
2932 return false;
2933 }
2934 break;
2935 case T_IntList:
2936 forboth(item_a, a, item_b, b)
2937 {
2938 if (lfirst_int(item_a) != lfirst_int(item_b))
2939 return false;
2940 }
2941 break;
2942 case T_OidList:
2943 forboth(item_a, a, item_b, b)
2944 {
2945 if (lfirst_oid(item_a) != lfirst_oid(item_b))
2946 return false;
2947 }
2948 break;
2949 default:
2950 elog(ERROR, "unrecognized list node type: %d",
2951 (int) a->type);
2952 return false; /* keep compiler quiet */
2953 }
2954
2955 /*
2956 * If we got here, we should have run out of elements of both lists
2957 */
2958 Assert(item_a == NULL);
2959 Assert(item_b == NULL);
2960
2961 return true;
2962 }
2963
2964 /*
2965 * Stuff from value.h
2966 */
2967
2968 static bool
_equalValue(const Value * a,const Value * b)2969 _equalValue(const Value *a, const Value *b)
2970 {
2971 COMPARE_SCALAR_FIELD(type);
2972
2973 switch (a->type)
2974 {
2975 case T_Integer:
2976 COMPARE_SCALAR_FIELD(val.ival);
2977 break;
2978 case T_Float:
2979 case T_String:
2980 case T_BitString:
2981 COMPARE_STRING_FIELD(val.str);
2982 break;
2983 case T_Null:
2984 /* nothing to do */
2985 break;
2986 default:
2987 elog(ERROR, "unrecognized node type: %d", (int) a->type);
2988 break;
2989 }
2990
2991 return true;
2992 }
2993
2994 /*
2995 * equal
2996 * returns whether two nodes are equal
2997 */
2998 bool
equal(const void * a,const void * b)2999 equal(const void *a, const void *b)
3000 {
3001 bool retval;
3002
3003 if (a == b)
3004 return true;
3005
3006 /*
3007 * note that a!=b, so only one of them can be NULL
3008 */
3009 if (a == NULL || b == NULL)
3010 return false;
3011
3012 /*
3013 * are they the same type of nodes?
3014 */
3015 if (nodeTag(a) != nodeTag(b))
3016 return false;
3017
3018 /* Guard against stack overflow due to overly complex expressions */
3019 check_stack_depth();
3020
3021 switch (nodeTag(a))
3022 {
3023 /*
3024 * PRIMITIVE NODES
3025 */
3026 case T_Alias:
3027 retval = _equalAlias(a, b);
3028 break;
3029 case T_RangeVar:
3030 retval = _equalRangeVar(a, b);
3031 break;
3032 case T_TableFunc:
3033 retval = _equalTableFunc(a, b);
3034 break;
3035 case T_IntoClause:
3036 retval = _equalIntoClause(a, b);
3037 break;
3038 case T_Var:
3039 retval = _equalVar(a, b);
3040 break;
3041 case T_Const:
3042 retval = _equalConst(a, b);
3043 break;
3044 case T_Param:
3045 retval = _equalParam(a, b);
3046 break;
3047 case T_Aggref:
3048 retval = _equalAggref(a, b);
3049 break;
3050 case T_GroupingFunc:
3051 retval = _equalGroupingFunc(a, b);
3052 break;
3053 case T_WindowFunc:
3054 retval = _equalWindowFunc(a, b);
3055 break;
3056 case T_SubscriptingRef:
3057 retval = _equalSubscriptingRef(a, b);
3058 break;
3059 case T_FuncExpr:
3060 retval = _equalFuncExpr(a, b);
3061 break;
3062 case T_NamedArgExpr:
3063 retval = _equalNamedArgExpr(a, b);
3064 break;
3065 case T_OpExpr:
3066 retval = _equalOpExpr(a, b);
3067 break;
3068 case T_DistinctExpr:
3069 retval = _equalDistinctExpr(a, b);
3070 break;
3071 case T_NullIfExpr:
3072 retval = _equalNullIfExpr(a, b);
3073 break;
3074 case T_ScalarArrayOpExpr:
3075 retval = _equalScalarArrayOpExpr(a, b);
3076 break;
3077 case T_BoolExpr:
3078 retval = _equalBoolExpr(a, b);
3079 break;
3080 case T_SubLink:
3081 retval = _equalSubLink(a, b);
3082 break;
3083 case T_SubPlan:
3084 retval = _equalSubPlan(a, b);
3085 break;
3086 case T_AlternativeSubPlan:
3087 retval = _equalAlternativeSubPlan(a, b);
3088 break;
3089 case T_FieldSelect:
3090 retval = _equalFieldSelect(a, b);
3091 break;
3092 case T_FieldStore:
3093 retval = _equalFieldStore(a, b);
3094 break;
3095 case T_RelabelType:
3096 retval = _equalRelabelType(a, b);
3097 break;
3098 case T_CoerceViaIO:
3099 retval = _equalCoerceViaIO(a, b);
3100 break;
3101 case T_ArrayCoerceExpr:
3102 retval = _equalArrayCoerceExpr(a, b);
3103 break;
3104 case T_ConvertRowtypeExpr:
3105 retval = _equalConvertRowtypeExpr(a, b);
3106 break;
3107 case T_CollateExpr:
3108 retval = _equalCollateExpr(a, b);
3109 break;
3110 case T_CaseExpr:
3111 retval = _equalCaseExpr(a, b);
3112 break;
3113 case T_CaseWhen:
3114 retval = _equalCaseWhen(a, b);
3115 break;
3116 case T_CaseTestExpr:
3117 retval = _equalCaseTestExpr(a, b);
3118 break;
3119 case T_ArrayExpr:
3120 retval = _equalArrayExpr(a, b);
3121 break;
3122 case T_RowExpr:
3123 retval = _equalRowExpr(a, b);
3124 break;
3125 case T_RowCompareExpr:
3126 retval = _equalRowCompareExpr(a, b);
3127 break;
3128 case T_CoalesceExpr:
3129 retval = _equalCoalesceExpr(a, b);
3130 break;
3131 case T_MinMaxExpr:
3132 retval = _equalMinMaxExpr(a, b);
3133 break;
3134 case T_SQLValueFunction:
3135 retval = _equalSQLValueFunction(a, b);
3136 break;
3137 case T_XmlExpr:
3138 retval = _equalXmlExpr(a, b);
3139 break;
3140 case T_NullTest:
3141 retval = _equalNullTest(a, b);
3142 break;
3143 case T_BooleanTest:
3144 retval = _equalBooleanTest(a, b);
3145 break;
3146 case T_CoerceToDomain:
3147 retval = _equalCoerceToDomain(a, b);
3148 break;
3149 case T_CoerceToDomainValue:
3150 retval = _equalCoerceToDomainValue(a, b);
3151 break;
3152 case T_SetToDefault:
3153 retval = _equalSetToDefault(a, b);
3154 break;
3155 case T_CurrentOfExpr:
3156 retval = _equalCurrentOfExpr(a, b);
3157 break;
3158 case T_NextValueExpr:
3159 retval = _equalNextValueExpr(a, b);
3160 break;
3161 case T_InferenceElem:
3162 retval = _equalInferenceElem(a, b);
3163 break;
3164 case T_TargetEntry:
3165 retval = _equalTargetEntry(a, b);
3166 break;
3167 case T_RangeTblRef:
3168 retval = _equalRangeTblRef(a, b);
3169 break;
3170 case T_FromExpr:
3171 retval = _equalFromExpr(a, b);
3172 break;
3173 case T_OnConflictExpr:
3174 retval = _equalOnConflictExpr(a, b);
3175 break;
3176 case T_JoinExpr:
3177 retval = _equalJoinExpr(a, b);
3178 break;
3179
3180 /*
3181 * RELATION NODES
3182 */
3183 case T_PathKey:
3184 retval = _equalPathKey(a, b);
3185 break;
3186 case T_RestrictInfo:
3187 retval = _equalRestrictInfo(a, b);
3188 break;
3189 case T_PlaceHolderVar:
3190 retval = _equalPlaceHolderVar(a, b);
3191 break;
3192 case T_SpecialJoinInfo:
3193 retval = _equalSpecialJoinInfo(a, b);
3194 break;
3195 case T_AppendRelInfo:
3196 retval = _equalAppendRelInfo(a, b);
3197 break;
3198 case T_PlaceHolderInfo:
3199 retval = _equalPlaceHolderInfo(a, b);
3200 break;
3201
3202 case T_List:
3203 case T_IntList:
3204 case T_OidList:
3205 retval = _equalList(a, b);
3206 break;
3207
3208 case T_Integer:
3209 case T_Float:
3210 case T_String:
3211 case T_BitString:
3212 case T_Null:
3213 retval = _equalValue(a, b);
3214 break;
3215
3216 /*
3217 * EXTENSIBLE NODES
3218 */
3219 case T_ExtensibleNode:
3220 retval = _equalExtensibleNode(a, b);
3221 break;
3222
3223 /*
3224 * PARSE NODES
3225 */
3226 case T_Query:
3227 retval = _equalQuery(a, b);
3228 break;
3229 case T_RawStmt:
3230 retval = _equalRawStmt(a, b);
3231 break;
3232 case T_InsertStmt:
3233 retval = _equalInsertStmt(a, b);
3234 break;
3235 case T_DeleteStmt:
3236 retval = _equalDeleteStmt(a, b);
3237 break;
3238 case T_UpdateStmt:
3239 retval = _equalUpdateStmt(a, b);
3240 break;
3241 case T_SelectStmt:
3242 retval = _equalSelectStmt(a, b);
3243 break;
3244 case T_SetOperationStmt:
3245 retval = _equalSetOperationStmt(a, b);
3246 break;
3247 case T_AlterTableStmt:
3248 retval = _equalAlterTableStmt(a, b);
3249 break;
3250 case T_AlterTableCmd:
3251 retval = _equalAlterTableCmd(a, b);
3252 break;
3253 case T_AlterCollationStmt:
3254 retval = _equalAlterCollationStmt(a, b);
3255 break;
3256 case T_AlterDomainStmt:
3257 retval = _equalAlterDomainStmt(a, b);
3258 break;
3259 case T_GrantStmt:
3260 retval = _equalGrantStmt(a, b);
3261 break;
3262 case T_GrantRoleStmt:
3263 retval = _equalGrantRoleStmt(a, b);
3264 break;
3265 case T_AlterDefaultPrivilegesStmt:
3266 retval = _equalAlterDefaultPrivilegesStmt(a, b);
3267 break;
3268 case T_DeclareCursorStmt:
3269 retval = _equalDeclareCursorStmt(a, b);
3270 break;
3271 case T_ClosePortalStmt:
3272 retval = _equalClosePortalStmt(a, b);
3273 break;
3274 case T_CallStmt:
3275 retval = _equalCallStmt(a, b);
3276 break;
3277 case T_ClusterStmt:
3278 retval = _equalClusterStmt(a, b);
3279 break;
3280 case T_CopyStmt:
3281 retval = _equalCopyStmt(a, b);
3282 break;
3283 case T_CreateStmt:
3284 retval = _equalCreateStmt(a, b);
3285 break;
3286 case T_TableLikeClause:
3287 retval = _equalTableLikeClause(a, b);
3288 break;
3289 case T_DefineStmt:
3290 retval = _equalDefineStmt(a, b);
3291 break;
3292 case T_DropStmt:
3293 retval = _equalDropStmt(a, b);
3294 break;
3295 case T_TruncateStmt:
3296 retval = _equalTruncateStmt(a, b);
3297 break;
3298 case T_CommentStmt:
3299 retval = _equalCommentStmt(a, b);
3300 break;
3301 case T_SecLabelStmt:
3302 retval = _equalSecLabelStmt(a, b);
3303 break;
3304 case T_FetchStmt:
3305 retval = _equalFetchStmt(a, b);
3306 break;
3307 case T_IndexStmt:
3308 retval = _equalIndexStmt(a, b);
3309 break;
3310 case T_CreateStatsStmt:
3311 retval = _equalCreateStatsStmt(a, b);
3312 break;
3313 case T_CreateFunctionStmt:
3314 retval = _equalCreateFunctionStmt(a, b);
3315 break;
3316 case T_FunctionParameter:
3317 retval = _equalFunctionParameter(a, b);
3318 break;
3319 case T_AlterFunctionStmt:
3320 retval = _equalAlterFunctionStmt(a, b);
3321 break;
3322 case T_DoStmt:
3323 retval = _equalDoStmt(a, b);
3324 break;
3325 case T_RenameStmt:
3326 retval = _equalRenameStmt(a, b);
3327 break;
3328 case T_AlterObjectDependsStmt:
3329 retval = _equalAlterObjectDependsStmt(a, b);
3330 break;
3331 case T_AlterObjectSchemaStmt:
3332 retval = _equalAlterObjectSchemaStmt(a, b);
3333 break;
3334 case T_AlterOwnerStmt:
3335 retval = _equalAlterOwnerStmt(a, b);
3336 break;
3337 case T_AlterOperatorStmt:
3338 retval = _equalAlterOperatorStmt(a, b);
3339 break;
3340 case T_RuleStmt:
3341 retval = _equalRuleStmt(a, b);
3342 break;
3343 case T_NotifyStmt:
3344 retval = _equalNotifyStmt(a, b);
3345 break;
3346 case T_ListenStmt:
3347 retval = _equalListenStmt(a, b);
3348 break;
3349 case T_UnlistenStmt:
3350 retval = _equalUnlistenStmt(a, b);
3351 break;
3352 case T_TransactionStmt:
3353 retval = _equalTransactionStmt(a, b);
3354 break;
3355 case T_CompositeTypeStmt:
3356 retval = _equalCompositeTypeStmt(a, b);
3357 break;
3358 case T_CreateEnumStmt:
3359 retval = _equalCreateEnumStmt(a, b);
3360 break;
3361 case T_CreateRangeStmt:
3362 retval = _equalCreateRangeStmt(a, b);
3363 break;
3364 case T_AlterEnumStmt:
3365 retval = _equalAlterEnumStmt(a, b);
3366 break;
3367 case T_ViewStmt:
3368 retval = _equalViewStmt(a, b);
3369 break;
3370 case T_LoadStmt:
3371 retval = _equalLoadStmt(a, b);
3372 break;
3373 case T_CreateDomainStmt:
3374 retval = _equalCreateDomainStmt(a, b);
3375 break;
3376 case T_CreateOpClassStmt:
3377 retval = _equalCreateOpClassStmt(a, b);
3378 break;
3379 case T_CreateOpClassItem:
3380 retval = _equalCreateOpClassItem(a, b);
3381 break;
3382 case T_CreateOpFamilyStmt:
3383 retval = _equalCreateOpFamilyStmt(a, b);
3384 break;
3385 case T_AlterOpFamilyStmt:
3386 retval = _equalAlterOpFamilyStmt(a, b);
3387 break;
3388 case T_CreatedbStmt:
3389 retval = _equalCreatedbStmt(a, b);
3390 break;
3391 case T_AlterDatabaseStmt:
3392 retval = _equalAlterDatabaseStmt(a, b);
3393 break;
3394 case T_AlterDatabaseSetStmt:
3395 retval = _equalAlterDatabaseSetStmt(a, b);
3396 break;
3397 case T_DropdbStmt:
3398 retval = _equalDropdbStmt(a, b);
3399 break;
3400 case T_VacuumStmt:
3401 retval = _equalVacuumStmt(a, b);
3402 break;
3403 case T_VacuumRelation:
3404 retval = _equalVacuumRelation(a, b);
3405 break;
3406 case T_ExplainStmt:
3407 retval = _equalExplainStmt(a, b);
3408 break;
3409 case T_CreateTableAsStmt:
3410 retval = _equalCreateTableAsStmt(a, b);
3411 break;
3412 case T_RefreshMatViewStmt:
3413 retval = _equalRefreshMatViewStmt(a, b);
3414 break;
3415 case T_ReplicaIdentityStmt:
3416 retval = _equalReplicaIdentityStmt(a, b);
3417 break;
3418 case T_AlterSystemStmt:
3419 retval = _equalAlterSystemStmt(a, b);
3420 break;
3421 case T_CreateSeqStmt:
3422 retval = _equalCreateSeqStmt(a, b);
3423 break;
3424 case T_AlterSeqStmt:
3425 retval = _equalAlterSeqStmt(a, b);
3426 break;
3427 case T_VariableSetStmt:
3428 retval = _equalVariableSetStmt(a, b);
3429 break;
3430 case T_VariableShowStmt:
3431 retval = _equalVariableShowStmt(a, b);
3432 break;
3433 case T_DiscardStmt:
3434 retval = _equalDiscardStmt(a, b);
3435 break;
3436 case T_CreateTableSpaceStmt:
3437 retval = _equalCreateTableSpaceStmt(a, b);
3438 break;
3439 case T_DropTableSpaceStmt:
3440 retval = _equalDropTableSpaceStmt(a, b);
3441 break;
3442 case T_AlterTableSpaceOptionsStmt:
3443 retval = _equalAlterTableSpaceOptionsStmt(a, b);
3444 break;
3445 case T_AlterTableMoveAllStmt:
3446 retval = _equalAlterTableMoveAllStmt(a, b);
3447 break;
3448 case T_CreateExtensionStmt:
3449 retval = _equalCreateExtensionStmt(a, b);
3450 break;
3451 case T_AlterExtensionStmt:
3452 retval = _equalAlterExtensionStmt(a, b);
3453 break;
3454 case T_AlterExtensionContentsStmt:
3455 retval = _equalAlterExtensionContentsStmt(a, b);
3456 break;
3457 case T_CreateFdwStmt:
3458 retval = _equalCreateFdwStmt(a, b);
3459 break;
3460 case T_AlterFdwStmt:
3461 retval = _equalAlterFdwStmt(a, b);
3462 break;
3463 case T_CreateForeignServerStmt:
3464 retval = _equalCreateForeignServerStmt(a, b);
3465 break;
3466 case T_AlterForeignServerStmt:
3467 retval = _equalAlterForeignServerStmt(a, b);
3468 break;
3469 case T_CreateUserMappingStmt:
3470 retval = _equalCreateUserMappingStmt(a, b);
3471 break;
3472 case T_AlterUserMappingStmt:
3473 retval = _equalAlterUserMappingStmt(a, b);
3474 break;
3475 case T_DropUserMappingStmt:
3476 retval = _equalDropUserMappingStmt(a, b);
3477 break;
3478 case T_CreateForeignTableStmt:
3479 retval = _equalCreateForeignTableStmt(a, b);
3480 break;
3481 case T_ImportForeignSchemaStmt:
3482 retval = _equalImportForeignSchemaStmt(a, b);
3483 break;
3484 case T_CreateTransformStmt:
3485 retval = _equalCreateTransformStmt(a, b);
3486 break;
3487 case T_CreateAmStmt:
3488 retval = _equalCreateAmStmt(a, b);
3489 break;
3490 case T_CreateTrigStmt:
3491 retval = _equalCreateTrigStmt(a, b);
3492 break;
3493 case T_CreateEventTrigStmt:
3494 retval = _equalCreateEventTrigStmt(a, b);
3495 break;
3496 case T_AlterEventTrigStmt:
3497 retval = _equalAlterEventTrigStmt(a, b);
3498 break;
3499 case T_CreatePLangStmt:
3500 retval = _equalCreatePLangStmt(a, b);
3501 break;
3502 case T_CreateRoleStmt:
3503 retval = _equalCreateRoleStmt(a, b);
3504 break;
3505 case T_AlterRoleStmt:
3506 retval = _equalAlterRoleStmt(a, b);
3507 break;
3508 case T_AlterRoleSetStmt:
3509 retval = _equalAlterRoleSetStmt(a, b);
3510 break;
3511 case T_DropRoleStmt:
3512 retval = _equalDropRoleStmt(a, b);
3513 break;
3514 case T_LockStmt:
3515 retval = _equalLockStmt(a, b);
3516 break;
3517 case T_ConstraintsSetStmt:
3518 retval = _equalConstraintsSetStmt(a, b);
3519 break;
3520 case T_ReindexStmt:
3521 retval = _equalReindexStmt(a, b);
3522 break;
3523 case T_CheckPointStmt:
3524 retval = true;
3525 break;
3526 case T_CreateSchemaStmt:
3527 retval = _equalCreateSchemaStmt(a, b);
3528 break;
3529 case T_CreateConversionStmt:
3530 retval = _equalCreateConversionStmt(a, b);
3531 break;
3532 case T_CreateCastStmt:
3533 retval = _equalCreateCastStmt(a, b);
3534 break;
3535 case T_PrepareStmt:
3536 retval = _equalPrepareStmt(a, b);
3537 break;
3538 case T_ExecuteStmt:
3539 retval = _equalExecuteStmt(a, b);
3540 break;
3541 case T_DeallocateStmt:
3542 retval = _equalDeallocateStmt(a, b);
3543 break;
3544 case T_DropOwnedStmt:
3545 retval = _equalDropOwnedStmt(a, b);
3546 break;
3547 case T_ReassignOwnedStmt:
3548 retval = _equalReassignOwnedStmt(a, b);
3549 break;
3550 case T_AlterTSDictionaryStmt:
3551 retval = _equalAlterTSDictionaryStmt(a, b);
3552 break;
3553 case T_AlterTSConfigurationStmt:
3554 retval = _equalAlterTSConfigurationStmt(a, b);
3555 break;
3556 case T_CreatePolicyStmt:
3557 retval = _equalCreatePolicyStmt(a, b);
3558 break;
3559 case T_AlterPolicyStmt:
3560 retval = _equalAlterPolicyStmt(a, b);
3561 break;
3562 case T_CreatePublicationStmt:
3563 retval = _equalCreatePublicationStmt(a, b);
3564 break;
3565 case T_AlterPublicationStmt:
3566 retval = _equalAlterPublicationStmt(a, b);
3567 break;
3568 case T_CreateSubscriptionStmt:
3569 retval = _equalCreateSubscriptionStmt(a, b);
3570 break;
3571 case T_AlterSubscriptionStmt:
3572 retval = _equalAlterSubscriptionStmt(a, b);
3573 break;
3574 case T_DropSubscriptionStmt:
3575 retval = _equalDropSubscriptionStmt(a, b);
3576 break;
3577 case T_A_Expr:
3578 retval = _equalAExpr(a, b);
3579 break;
3580 case T_ColumnRef:
3581 retval = _equalColumnRef(a, b);
3582 break;
3583 case T_ParamRef:
3584 retval = _equalParamRef(a, b);
3585 break;
3586 case T_A_Const:
3587 retval = _equalAConst(a, b);
3588 break;
3589 case T_FuncCall:
3590 retval = _equalFuncCall(a, b);
3591 break;
3592 case T_A_Star:
3593 retval = _equalAStar(a, b);
3594 break;
3595 case T_A_Indices:
3596 retval = _equalAIndices(a, b);
3597 break;
3598 case T_A_Indirection:
3599 retval = _equalA_Indirection(a, b);
3600 break;
3601 case T_A_ArrayExpr:
3602 retval = _equalA_ArrayExpr(a, b);
3603 break;
3604 case T_ResTarget:
3605 retval = _equalResTarget(a, b);
3606 break;
3607 case T_MultiAssignRef:
3608 retval = _equalMultiAssignRef(a, b);
3609 break;
3610 case T_TypeCast:
3611 retval = _equalTypeCast(a, b);
3612 break;
3613 case T_CollateClause:
3614 retval = _equalCollateClause(a, b);
3615 break;
3616 case T_SortBy:
3617 retval = _equalSortBy(a, b);
3618 break;
3619 case T_WindowDef:
3620 retval = _equalWindowDef(a, b);
3621 break;
3622 case T_RangeSubselect:
3623 retval = _equalRangeSubselect(a, b);
3624 break;
3625 case T_RangeFunction:
3626 retval = _equalRangeFunction(a, b);
3627 break;
3628 case T_RangeTableSample:
3629 retval = _equalRangeTableSample(a, b);
3630 break;
3631 case T_RangeTableFunc:
3632 retval = _equalRangeTableFunc(a, b);
3633 break;
3634 case T_RangeTableFuncCol:
3635 retval = _equalRangeTableFuncCol(a, b);
3636 break;
3637 case T_TypeName:
3638 retval = _equalTypeName(a, b);
3639 break;
3640 case T_IndexElem:
3641 retval = _equalIndexElem(a, b);
3642 break;
3643 case T_ColumnDef:
3644 retval = _equalColumnDef(a, b);
3645 break;
3646 case T_Constraint:
3647 retval = _equalConstraint(a, b);
3648 break;
3649 case T_DefElem:
3650 retval = _equalDefElem(a, b);
3651 break;
3652 case T_LockingClause:
3653 retval = _equalLockingClause(a, b);
3654 break;
3655 case T_RangeTblEntry:
3656 retval = _equalRangeTblEntry(a, b);
3657 break;
3658 case T_RangeTblFunction:
3659 retval = _equalRangeTblFunction(a, b);
3660 break;
3661 case T_TableSampleClause:
3662 retval = _equalTableSampleClause(a, b);
3663 break;
3664 case T_WithCheckOption:
3665 retval = _equalWithCheckOption(a, b);
3666 break;
3667 case T_SortGroupClause:
3668 retval = _equalSortGroupClause(a, b);
3669 break;
3670 case T_GroupingSet:
3671 retval = _equalGroupingSet(a, b);
3672 break;
3673 case T_WindowClause:
3674 retval = _equalWindowClause(a, b);
3675 break;
3676 case T_RowMarkClause:
3677 retval = _equalRowMarkClause(a, b);
3678 break;
3679 case T_WithClause:
3680 retval = _equalWithClause(a, b);
3681 break;
3682 case T_InferClause:
3683 retval = _equalInferClause(a, b);
3684 break;
3685 case T_OnConflictClause:
3686 retval = _equalOnConflictClause(a, b);
3687 break;
3688 case T_CommonTableExpr:
3689 retval = _equalCommonTableExpr(a, b);
3690 break;
3691 case T_ObjectWithArgs:
3692 retval = _equalObjectWithArgs(a, b);
3693 break;
3694 case T_AccessPriv:
3695 retval = _equalAccessPriv(a, b);
3696 break;
3697 case T_XmlSerialize:
3698 retval = _equalXmlSerialize(a, b);
3699 break;
3700 case T_RoleSpec:
3701 retval = _equalRoleSpec(a, b);
3702 break;
3703 case T_TriggerTransition:
3704 retval = _equalTriggerTransition(a, b);
3705 break;
3706 case T_PartitionElem:
3707 retval = _equalPartitionElem(a, b);
3708 break;
3709 case T_PartitionSpec:
3710 retval = _equalPartitionSpec(a, b);
3711 break;
3712 case T_PartitionBoundSpec:
3713 retval = _equalPartitionBoundSpec(a, b);
3714 break;
3715 case T_PartitionRangeDatum:
3716 retval = _equalPartitionRangeDatum(a, b);
3717 break;
3718 case T_PartitionCmd:
3719 retval = _equalPartitionCmd(a, b);
3720 break;
3721
3722 default:
3723 elog(ERROR, "unrecognized node type: %d",
3724 (int) nodeTag(a));
3725 retval = false; /* keep compiler quiet */
3726 break;
3727 }
3728
3729 return retval;
3730 }
3731