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