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