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