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