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