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