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