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