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 : 1763625 : _equalAlias(const Alias *a, const Alias *b)
44 : : {
45 [ + - + - : 1763625 : COMPARE_STRING_FIELD(aliasname);
+ + ]
46 [ - + ]: 1763614 : COMPARE_NODE_FIELD(colnames);
47 : :
48 : 1763614 : return true;
49 : : }
50 : :
51 : : static bool
52 : 1156807 : _equalRangeVar(const RangeVar *a, const RangeVar *b)
53 : : {
54 [ - + - - : 1156807 : COMPARE_STRING_FIELD(catalogname);
- + ]
55 [ + + + + : 1156807 : COMPARE_STRING_FIELD(schemaname);
+ + ]
56 [ + - + - : 1156757 : COMPARE_STRING_FIELD(relname);
+ + ]
57 [ - + ]: 1155391 : COMPARE_SCALAR_FIELD(inh);
58 [ - + ]: 1155391 : COMPARE_SCALAR_FIELD(relpersistence);
59 [ - + ]: 1155391 : COMPARE_NODE_FIELD(alias);
60 : : COMPARE_LOCATION_FIELD(location);
61 : :
62 : 1155391 : 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 : 5210 : _equalIntoClause(const IntoClause *a, const IntoClause *b)
91 : : {
92 [ - + ]: 5210 : COMPARE_NODE_FIELD(rel);
93 [ - + ]: 5210 : COMPARE_NODE_FIELD(colNames);
94 [ + + + - : 5210 : COMPARE_STRING_FIELD(accessMethod);
- + ]
95 [ - + ]: 5210 : COMPARE_NODE_FIELD(options);
96 [ - + ]: 5210 : COMPARE_SCALAR_FIELD(onCommit);
97 [ + + + - : 5210 : COMPARE_STRING_FIELD(tableSpaceName);
- + ]
98 [ - + ]: 5210 : COMPARE_NODE_FIELD(viewQuery);
99 [ - + ]: 5210 : COMPARE_SCALAR_FIELD(skipData);
100 : :
101 : 5210 : return true;
102 : : }
103 : :
104 : : static bool
105 : 13048207 : _equalVar(const Var *a, const Var *b)
106 : : {
107 [ + + ]: 13048207 : COMPARE_SCALAR_FIELD(varno);
108 [ + + ]: 10279632 : COMPARE_SCALAR_FIELD(varattno);
109 [ - + ]: 8961974 : COMPARE_SCALAR_FIELD(vartype);
110 [ - + ]: 8961974 : COMPARE_SCALAR_FIELD(vartypmod);
111 [ - + ]: 8961974 : COMPARE_SCALAR_FIELD(varcollid);
112 [ + + ]: 8961974 : COMPARE_BITMAPSET_FIELD(varnullingrels);
113 [ + + ]: 8948835 : COMPARE_SCALAR_FIELD(varlevelsup);
114 [ - + ]: 8948831 : COMPARE_SCALAR_FIELD(varreturningtype);
115 : : COMPARE_LOCATION_FIELD(location);
116 : :
117 : 8948831 : return true;
118 : : }
119 : :
120 : : static bool
121 : 108819 : _equalParam(const Param *a, const Param *b)
122 : : {
123 [ + + ]: 108819 : COMPARE_SCALAR_FIELD(paramkind);
124 [ + + ]: 106735 : COMPARE_SCALAR_FIELD(paramid);
125 [ - + ]: 96395 : COMPARE_SCALAR_FIELD(paramtype);
126 [ - + ]: 96395 : COMPARE_SCALAR_FIELD(paramtypmod);
127 [ - + ]: 96395 : COMPARE_SCALAR_FIELD(paramcollid);
128 : : COMPARE_LOCATION_FIELD(location);
129 : :
130 : 96395 : return true;
131 : : }
132 : :
133 : : static bool
134 : 81442 : _equalAggref(const Aggref *a, const Aggref *b)
135 : : {
136 [ + + ]: 81442 : COMPARE_SCALAR_FIELD(aggfnoid);
137 [ + + ]: 72204 : COMPARE_SCALAR_FIELD(aggtype);
138 [ - + ]: 71694 : COMPARE_SCALAR_FIELD(aggcollid);
139 [ - + ]: 71694 : COMPARE_SCALAR_FIELD(inputcollid);
140 [ - + ]: 71694 : COMPARE_NODE_FIELD(aggargtypes);
141 [ - + ]: 71694 : COMPARE_NODE_FIELD(aggdirectargs);
142 [ + + ]: 71694 : COMPARE_NODE_FIELD(args);
143 [ - + ]: 69670 : COMPARE_NODE_FIELD(aggorder);
144 [ - + ]: 69670 : COMPARE_NODE_FIELD(aggdistinct);
145 [ + + ]: 69670 : COMPARE_NODE_FIELD(aggfilter);
146 [ - + ]: 69655 : COMPARE_SCALAR_FIELD(aggstar);
147 [ - + ]: 69655 : COMPARE_SCALAR_FIELD(aggvariadic);
148 [ - + ]: 69655 : COMPARE_SCALAR_FIELD(aggkind);
149 [ - + ]: 69655 : COMPARE_SCALAR_FIELD(agglevelsup);
150 [ + + ]: 69655 : COMPARE_SCALAR_FIELD(aggsplit);
151 [ - + ]: 69625 : COMPARE_SCALAR_FIELD(aggno);
152 [ - + ]: 69625 : COMPARE_SCALAR_FIELD(aggtransno);
153 : : COMPARE_LOCATION_FIELD(location);
154 : :
155 : 69625 : 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 : 6798 : _equalWindowFunc(const WindowFunc *a, const WindowFunc *b)
170 : : {
171 [ + + ]: 6798 : COMPARE_SCALAR_FIELD(winfnoid);
172 [ - + ]: 5777 : COMPARE_SCALAR_FIELD(wintype);
173 [ - + ]: 5777 : COMPARE_SCALAR_FIELD(wincollid);
174 [ - + ]: 5777 : COMPARE_SCALAR_FIELD(inputcollid);
175 [ + + ]: 5777 : COMPARE_NODE_FIELD(args);
176 [ + + ]: 5689 : COMPARE_NODE_FIELD(aggfilter);
177 [ - + ]: 5680 : COMPARE_NODE_FIELD(runCondition);
178 [ + + ]: 5680 : COMPARE_SCALAR_FIELD(winref);
179 [ - + ]: 5580 : COMPARE_SCALAR_FIELD(winstar);
180 [ - + ]: 5580 : COMPARE_SCALAR_FIELD(winagg);
181 [ + + ]: 5580 : COMPARE_SCALAR_FIELD(ignore_nulls);
182 : : COMPARE_LOCATION_FIELD(location);
183 : :
184 : 5517 : 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 : 21221 : _equalSubscriptingRef(const SubscriptingRef *a, const SubscriptingRef *b)
210 : : {
211 [ - + ]: 21221 : COMPARE_SCALAR_FIELD(refcontainertype);
212 [ - + ]: 21221 : COMPARE_SCALAR_FIELD(refelemtype);
213 [ - + ]: 21221 : COMPARE_SCALAR_FIELD(refrestype);
214 [ - + ]: 21221 : COMPARE_SCALAR_FIELD(reftypmod);
215 [ - + ]: 21221 : COMPARE_SCALAR_FIELD(refcollid);
216 [ + + ]: 21221 : COMPARE_NODE_FIELD(refupperindexpr);
217 [ - + ]: 21155 : COMPARE_NODE_FIELD(reflowerindexpr);
218 [ + + ]: 21155 : COMPARE_NODE_FIELD(refexpr);
219 [ - + ]: 20952 : COMPARE_NODE_FIELD(refassgnexpr);
220 : :
221 : 20952 : return true;
222 : : }
223 : :
224 : : static bool
225 : 552096 : _equalFuncExpr(const FuncExpr *a, const FuncExpr *b)
226 : : {
227 [ + + ]: 552096 : COMPARE_SCALAR_FIELD(funcid);
228 [ + + ]: 550258 : COMPARE_SCALAR_FIELD(funcresulttype);
229 [ - + ]: 550138 : COMPARE_SCALAR_FIELD(funcretset);
230 [ - + ]: 550138 : COMPARE_SCALAR_FIELD(funcvariadic);
231 [ - + ]: 550138 : COMPARE_SCALAR_FIELD(funccollid);
232 [ - + ]: 550138 : COMPARE_SCALAR_FIELD(inputcollid);
233 [ + + ]: 550138 : COMPARE_NODE_FIELD(args);
234 : : COMPARE_LOCATION_FIELD(location);
235 : :
236 : 547968 : return true;
237 : : }
238 : :
239 : : static bool
240 : 101796 : _equalNamedArgExpr(const NamedArgExpr *a, const NamedArgExpr *b)
241 : : {
242 [ - + ]: 101796 : COMPARE_NODE_FIELD(arg);
243 [ + - + - : 101796 : COMPARE_STRING_FIELD(name);
- + ]
244 [ - + ]: 101796 : COMPARE_SCALAR_FIELD(argnumber);
245 : : COMPARE_LOCATION_FIELD(location);
246 : :
247 : 101796 : return true;
248 : : }
249 : :
250 : : static bool
251 : 1044176 : _equalOpExpr(const OpExpr *a, const OpExpr *b)
252 : : {
253 [ + + ]: 1044176 : COMPARE_SCALAR_FIELD(opno);
254 [ + + + + : 950642 : if (a->opfuncid != b->opfuncid && a->opfuncid != 0 && b->opfuncid != 0)
- + ]
255 : 0 : return false;
256 [ - + ]: 950642 : COMPARE_SCALAR_FIELD(opresulttype);
257 [ - + ]: 950642 : COMPARE_SCALAR_FIELD(opretset);
258 [ - + ]: 950642 : COMPARE_SCALAR_FIELD(opcollid);
259 [ + + ]: 950642 : COMPARE_SCALAR_FIELD(inputcollid);
260 [ + + ]: 950641 : COMPARE_NODE_FIELD(args);
261 : : COMPARE_LOCATION_FIELD(location);
262 : :
263 : 845499 : return true;
264 : : }
265 : :
266 : : static bool
267 : 1398 : _equalDistinctExpr(const DistinctExpr *a, const DistinctExpr *b)
268 : : {
269 [ - + ]: 1398 : COMPARE_SCALAR_FIELD(opno);
270 [ - + - - : 1398 : if (a->opfuncid != b->opfuncid && a->opfuncid != 0 && b->opfuncid != 0)
- - ]
271 : 0 : return false;
272 [ - + ]: 1398 : COMPARE_SCALAR_FIELD(opresulttype);
273 [ - + ]: 1398 : COMPARE_SCALAR_FIELD(opretset);
274 [ - + ]: 1398 : COMPARE_SCALAR_FIELD(opcollid);
275 [ - + ]: 1398 : COMPARE_SCALAR_FIELD(inputcollid);
276 [ - + ]: 1398 : COMPARE_NODE_FIELD(args);
277 : : COMPARE_LOCATION_FIELD(location);
278 : :
279 : 1398 : 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 : 42851 : _equalScalarArrayOpExpr(const ScalarArrayOpExpr *a, const ScalarArrayOpExpr *b)
300 : : {
301 [ + + ]: 42851 : COMPARE_SCALAR_FIELD(opno);
302 [ - + - - : 42328 : if (a->opfuncid != b->opfuncid && a->opfuncid != 0 && b->opfuncid != 0)
- - ]
303 : 0 : return false;
304 [ - + - - : 42328 : if (a->hashfuncid != b->hashfuncid && a->hashfuncid != 0 && b->hashfuncid != 0)
- - ]
305 : 0 : return false;
306 [ - + - - : 42328 : if (a->negfuncid != b->negfuncid && a->negfuncid != 0 && b->negfuncid != 0)
- - ]
307 : 0 : return false;
308 [ - + ]: 42328 : COMPARE_SCALAR_FIELD(useOr);
309 [ - + ]: 42328 : COMPARE_SCALAR_FIELD(inputcollid);
310 [ + + ]: 42328 : COMPARE_NODE_FIELD(args);
311 : : COMPARE_LOCATION_FIELD(location);
312 : :
313 : 42268 : return true;
314 : : }
315 : :
316 : : static bool
317 : 495996 : _equalBoolExpr(const BoolExpr *a, const BoolExpr *b)
318 : : {
319 [ - + ]: 495996 : COMPARE_SCALAR_FIELD(boolop);
320 [ + + ]: 495996 : COMPARE_NODE_FIELD(args);
321 : : COMPARE_LOCATION_FIELD(location);
322 : :
323 : 494789 : return true;
324 : : }
325 : :
326 : : static bool
327 : 140924 : _equalSubLink(const SubLink *a, const SubLink *b)
328 : : {
329 [ - + ]: 140924 : COMPARE_SCALAR_FIELD(subLinkType);
330 [ - + ]: 140924 : COMPARE_SCALAR_FIELD(subLinkId);
331 [ + + ]: 140924 : COMPARE_NODE_FIELD(testexpr);
332 [ - + ]: 140914 : COMPARE_NODE_FIELD(operName);
333 [ + + ]: 140914 : COMPARE_NODE_FIELD(subselect);
334 : : COMPARE_LOCATION_FIELD(location);
335 : :
336 : 140894 : return true;
337 : : }
338 : :
339 : : static bool
340 : 5556 : _equalSubPlan(const SubPlan *a, const SubPlan *b)
341 : : {
342 [ - + ]: 5556 : COMPARE_SCALAR_FIELD(subLinkType);
343 [ - + ]: 5556 : COMPARE_NODE_FIELD(testexpr);
344 [ - + ]: 5556 : COMPARE_NODE_FIELD(paramIds);
345 [ + + ]: 5556 : COMPARE_SCALAR_FIELD(plan_id);
346 [ + - + - : 5416 : COMPARE_STRING_FIELD(plan_name);
- + ]
347 [ - + ]: 5416 : COMPARE_SCALAR_FIELD(firstColType);
348 [ - + ]: 5416 : COMPARE_SCALAR_FIELD(firstColTypmod);
349 [ - + ]: 5416 : COMPARE_SCALAR_FIELD(firstColCollation);
350 [ - + ]: 5416 : COMPARE_SCALAR_FIELD(isInitPlan);
351 [ - + ]: 5416 : COMPARE_SCALAR_FIELD(useHashTable);
352 [ - + ]: 5416 : COMPARE_SCALAR_FIELD(unknownEqFalse);
353 [ - + ]: 5416 : COMPARE_SCALAR_FIELD(parallel_safe);
354 [ - + ]: 5416 : COMPARE_NODE_FIELD(setParam);
355 [ - + ]: 5416 : COMPARE_NODE_FIELD(parParam);
356 [ - + ]: 5416 : COMPARE_NODE_FIELD(args);
357 [ - + ]: 5416 : COMPARE_SCALAR_FIELD(disabled_nodes);
358 [ - + ]: 5416 : COMPARE_SCALAR_FIELD(startup_cost);
359 [ - + ]: 5416 : COMPARE_SCALAR_FIELD(per_call_cost);
360 : :
361 : 5416 : 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 : 29283 : _equalFieldSelect(const FieldSelect *a, const FieldSelect *b)
374 : : {
375 [ + + ]: 29283 : COMPARE_NODE_FIELD(arg);
376 [ + + ]: 29273 : COMPARE_SCALAR_FIELD(fieldnum);
377 [ - + ]: 29193 : COMPARE_SCALAR_FIELD(resulttype);
378 [ - + ]: 29193 : COMPARE_SCALAR_FIELD(resulttypmod);
379 [ - + ]: 29193 : COMPARE_SCALAR_FIELD(resultcollid);
380 : :
381 : 29193 : 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 : 216665 : _equalRelabelType(const RelabelType *a, const RelabelType *b)
397 : : {
398 [ + + ]: 216665 : COMPARE_NODE_FIELD(arg);
399 [ - + ]: 212260 : COMPARE_SCALAR_FIELD(resulttype);
400 [ - + ]: 212260 : COMPARE_SCALAR_FIELD(resulttypmod);
401 [ - + ]: 212260 : COMPARE_SCALAR_FIELD(resultcollid);
402 : : COMPARE_LOCATION_FIELD(location);
403 : :
404 : 212260 : return true;
405 : : }
406 : :
407 : : static bool
408 : 40279 : _equalCoerceViaIO(const CoerceViaIO *a, const CoerceViaIO *b)
409 : : {
410 [ + + ]: 40279 : COMPARE_NODE_FIELD(arg);
411 [ - + ]: 40178 : COMPARE_SCALAR_FIELD(resulttype);
412 [ - + ]: 40178 : COMPARE_SCALAR_FIELD(resultcollid);
413 : : COMPARE_LOCATION_FIELD(location);
414 : :
415 : 40178 : return true;
416 : : }
417 : :
418 : : static bool
419 : 6870 : _equalArrayCoerceExpr(const ArrayCoerceExpr *a, const ArrayCoerceExpr *b)
420 : : {
421 [ - + ]: 6870 : COMPARE_NODE_FIELD(arg);
422 [ - + ]: 6870 : COMPARE_NODE_FIELD(elemexpr);
423 [ - + ]: 6870 : COMPARE_SCALAR_FIELD(resulttype);
424 [ - + ]: 6870 : COMPARE_SCALAR_FIELD(resulttypmod);
425 [ - + ]: 6870 : COMPARE_SCALAR_FIELD(resultcollid);
426 : : COMPARE_LOCATION_FIELD(location);
427 : :
428 : 6870 : 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 : 13772 : _equalCollateExpr(const CollateExpr *a, const CollateExpr *b)
443 : : {
444 [ + + ]: 13772 : COMPARE_NODE_FIELD(arg);
445 [ - + ]: 13720 : COMPARE_SCALAR_FIELD(collOid);
446 : : COMPARE_LOCATION_FIELD(location);
447 : :
448 : 13720 : return true;
449 : : }
450 : :
451 : : static bool
452 : 127313 : _equalCaseExpr(const CaseExpr *a, const CaseExpr *b)
453 : : {
454 [ - + ]: 127313 : COMPARE_SCALAR_FIELD(casetype);
455 [ + + ]: 127313 : COMPARE_SCALAR_FIELD(casecollid);
456 [ + + ]: 127303 : COMPARE_NODE_FIELD(arg);
457 [ + + ]: 127268 : COMPARE_NODE_FIELD(args);
458 [ - + ]: 127200 : COMPARE_NODE_FIELD(defresult);
459 : : COMPARE_LOCATION_FIELD(location);
460 : :
461 : 127200 : return true;
462 : : }
463 : :
464 : : static bool
465 : 242499 : _equalCaseWhen(const CaseWhen *a, const CaseWhen *b)
466 : : {
467 [ + + ]: 242499 : COMPARE_NODE_FIELD(expr);
468 [ - + ]: 242431 : COMPARE_NODE_FIELD(result);
469 : : COMPARE_LOCATION_FIELD(location);
470 : :
471 : 242431 : return true;
472 : : }
473 : :
474 : : static bool
475 : 36949 : _equalCaseTestExpr(const CaseTestExpr *a, const CaseTestExpr *b)
476 : : {
477 [ - + ]: 36949 : COMPARE_SCALAR_FIELD(typeId);
478 [ - + ]: 36949 : COMPARE_SCALAR_FIELD(typeMod);
479 [ - + ]: 36949 : COMPARE_SCALAR_FIELD(collation);
480 : :
481 : 36949 : return true;
482 : : }
483 : :
484 : : static bool
485 : 32679 : _equalArrayExpr(const ArrayExpr *a, const ArrayExpr *b)
486 : : {
487 [ - + ]: 32679 : COMPARE_SCALAR_FIELD(array_typeid);
488 [ - + ]: 32679 : COMPARE_SCALAR_FIELD(array_collid);
489 [ - + ]: 32679 : COMPARE_SCALAR_FIELD(element_typeid);
490 [ - + ]: 32679 : COMPARE_NODE_FIELD(elements);
491 [ - + ]: 32679 : COMPARE_SCALAR_FIELD(multidims);
492 : : COMPARE_LOCATION_FIELD(list_start);
493 : : COMPARE_LOCATION_FIELD(list_end);
494 : : COMPARE_LOCATION_FIELD(location);
495 : :
496 : 32679 : return true;
497 : : }
498 : :
499 : : static bool
500 : 15967 : _equalRowExpr(const RowExpr *a, const RowExpr *b)
501 : : {
502 [ - + ]: 15967 : COMPARE_NODE_FIELD(args);
503 [ - + ]: 15967 : COMPARE_SCALAR_FIELD(row_typeid);
504 [ - + ]: 15967 : COMPARE_NODE_FIELD(colnames);
505 : : COMPARE_LOCATION_FIELD(location);
506 : :
507 : 15967 : 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 : 12063 : _equalCoalesceExpr(const CoalesceExpr *a, const CoalesceExpr *b)
525 : : {
526 [ + + ]: 12063 : COMPARE_SCALAR_FIELD(coalescetype);
527 [ - + ]: 12061 : COMPARE_SCALAR_FIELD(coalescecollid);
528 [ + + ]: 12061 : COMPARE_NODE_FIELD(args);
529 : : COMPARE_LOCATION_FIELD(location);
530 : :
531 : 11322 : return true;
532 : : }
533 : :
534 : : static bool
535 : 781 : _equalMinMaxExpr(const MinMaxExpr *a, const MinMaxExpr *b)
536 : : {
537 [ - + ]: 781 : COMPARE_SCALAR_FIELD(minmaxtype);
538 [ - + ]: 781 : COMPARE_SCALAR_FIELD(minmaxcollid);
539 [ - + ]: 781 : COMPARE_SCALAR_FIELD(inputcollid);
540 [ - + ]: 781 : COMPARE_SCALAR_FIELD(op);
541 [ - + ]: 781 : COMPARE_NODE_FIELD(args);
542 : : COMPARE_LOCATION_FIELD(location);
543 : :
544 : 781 : return true;
545 : : }
546 : :
547 : : static bool
548 : 9717 : _equalSQLValueFunction(const SQLValueFunction *a, const SQLValueFunction *b)
549 : : {
550 [ + + ]: 9717 : COMPARE_SCALAR_FIELD(op);
551 [ - + ]: 9667 : COMPARE_SCALAR_FIELD(type);
552 [ - + ]: 9667 : COMPARE_SCALAR_FIELD(typmod);
553 : : COMPARE_LOCATION_FIELD(location);
554 : :
555 : 9667 : 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 : 51566 : _equalNullTest(const NullTest *a, const NullTest *b)
703 : : {
704 [ + + ]: 51566 : COMPARE_NODE_FIELD(arg);
705 [ + + ]: 50666 : COMPARE_SCALAR_FIELD(nulltesttype);
706 [ - + ]: 50601 : COMPARE_SCALAR_FIELD(argisrow);
707 : : COMPARE_LOCATION_FIELD(location);
708 : :
709 : 50601 : return true;
710 : : }
711 : :
712 : : static bool
713 : 3238 : _equalBooleanTest(const BooleanTest *a, const BooleanTest *b)
714 : : {
715 [ - + ]: 3238 : COMPARE_NODE_FIELD(arg);
716 [ + + ]: 3238 : COMPARE_SCALAR_FIELD(booltesttype);
717 : : COMPARE_LOCATION_FIELD(location);
718 : :
719 : 3218 : 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 : 2101094 : _equalTargetEntry(const TargetEntry *a, const TargetEntry *b)
832 : : {
833 [ + + ]: 2101094 : COMPARE_NODE_FIELD(expr);
834 [ - + ]: 2097176 : COMPARE_SCALAR_FIELD(resno);
835 [ + + + - : 2097176 : COMPARE_STRING_FIELD(resname);
- + ]
836 [ + + ]: 2097176 : COMPARE_SCALAR_FIELD(ressortgroupref);
837 [ - + ]: 2097141 : COMPARE_SCALAR_FIELD(resorigtbl);
838 [ - + ]: 2097141 : COMPARE_SCALAR_FIELD(resorigcol);
839 [ - + ]: 2097141 : COMPARE_SCALAR_FIELD(resjunk);
840 : :
841 : 2097141 : return true;
842 : : }
843 : :
844 : : static bool
845 : 705573 : _equalRangeTblRef(const RangeTblRef *a, const RangeTblRef *b)
846 : : {
847 [ - + ]: 705573 : COMPARE_SCALAR_FIELD(rtindex);
848 : :
849 : 705573 : return true;
850 : : }
851 : :
852 : : static bool
853 : 248244 : _equalJoinExpr(const JoinExpr *a, const JoinExpr *b)
854 : : {
855 [ - + ]: 248244 : COMPARE_SCALAR_FIELD(jointype);
856 [ - + ]: 248244 : COMPARE_SCALAR_FIELD(isNatural);
857 [ - + ]: 248244 : COMPARE_NODE_FIELD(larg);
858 [ - + ]: 248244 : COMPARE_NODE_FIELD(rarg);
859 [ - + ]: 248244 : COMPARE_NODE_FIELD(usingClause);
860 [ - + ]: 248244 : COMPARE_NODE_FIELD(join_using_alias);
861 [ - + ]: 248244 : COMPARE_NODE_FIELD(quals);
862 [ - + ]: 248244 : COMPARE_NODE_FIELD(alias);
863 [ - + ]: 248244 : COMPARE_SCALAR_FIELD(rtindex);
864 : :
865 : 248244 : return true;
866 : : }
867 : :
868 : : static bool
869 : 751848 : _equalFromExpr(const FromExpr *a, const FromExpr *b)
870 : : {
871 [ - + ]: 751848 : COMPARE_NODE_FIELD(fromlist);
872 [ + + ]: 751848 : COMPARE_NODE_FIELD(quals);
873 : :
874 : 751800 : 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 : 1994 : _equalForPortionOfExpr(const ForPortionOfExpr *a, const ForPortionOfExpr *b)
895 : : {
896 [ - + ]: 1994 : COMPARE_NODE_FIELD(rangeVar);
897 [ - + ]: 1994 : COMPARE_NODE_FIELD(targetFrom);
898 [ - + ]: 1994 : COMPARE_NODE_FIELD(targetTo);
899 [ - + ]: 1994 : COMPARE_NODE_FIELD(targetRange);
900 [ - + ]: 1994 : COMPARE_SCALAR_FIELD(rangeType);
901 [ - + ]: 1994 : COMPARE_SCALAR_FIELD(isDomain);
902 [ - + ]: 1994 : COMPARE_NODE_FIELD(overlapsExpr);
903 [ - + ]: 1994 : COMPARE_NODE_FIELD(rangeTargetList);
904 [ - + ]: 1994 : COMPARE_SCALAR_FIELD(withoutPortionProc);
905 : : COMPARE_LOCATION_FIELD(location);
906 : : COMPARE_LOCATION_FIELD(targetLocation);
907 : :
908 : 1994 : return true;
909 : : }
910 : :
911 : : static bool
912 : 1245504 : _equalQuery(const Query *a, const Query *b)
913 : : {
914 [ - + ]: 1245504 : COMPARE_SCALAR_FIELD(commandType);
915 [ - + ]: 1245504 : COMPARE_SCALAR_FIELD(querySource);
916 [ - + ]: 1245504 : COMPARE_SCALAR_FIELD(canSetTag);
917 [ - + ]: 1245504 : COMPARE_NODE_FIELD(utilityStmt);
918 [ - + ]: 1245504 : COMPARE_SCALAR_FIELD(resultRelation);
919 [ - + ]: 1245504 : COMPARE_NODE_FIELD(forPortionOf);
920 [ - + ]: 1245504 : COMPARE_SCALAR_FIELD(hasAggs);
921 [ - + ]: 1245504 : COMPARE_SCALAR_FIELD(hasWindowFuncs);
922 [ - + ]: 1245504 : COMPARE_SCALAR_FIELD(hasTargetSRFs);
923 [ + + ]: 1245504 : COMPARE_SCALAR_FIELD(hasSubLinks);
924 [ - + ]: 1245500 : COMPARE_SCALAR_FIELD(hasDistinctOn);
925 [ - + ]: 1245500 : COMPARE_SCALAR_FIELD(hasRecursive);
926 [ - + ]: 1245500 : COMPARE_SCALAR_FIELD(hasModifyingCTE);
927 [ - + ]: 1245500 : COMPARE_SCALAR_FIELD(hasForUpdate);
928 [ - + ]: 1245500 : COMPARE_SCALAR_FIELD(hasRowSecurity);
929 [ + + ]: 1245500 : COMPARE_SCALAR_FIELD(hasGroupRTE);
930 [ - + ]: 1245498 : COMPARE_SCALAR_FIELD(isReturn);
931 [ + + ]: 1245498 : COMPARE_NODE_FIELD(cteList);
932 [ + + ]: 1245494 : COMPARE_NODE_FIELD(rtable);
933 [ + + ]: 1245446 : COMPARE_NODE_FIELD(rteperminfos);
934 [ + + ]: 1245413 : COMPARE_NODE_FIELD(jointree);
935 [ - + ]: 1245365 : COMPARE_NODE_FIELD(mergeActionList);
936 [ - + ]: 1245365 : COMPARE_SCALAR_FIELD(mergeTargetRelation);
937 [ - + ]: 1245365 : COMPARE_NODE_FIELD(mergeJoinCondition);
938 [ + + ]: 1245365 : COMPARE_NODE_FIELD(targetList);
939 [ - + ]: 1245326 : COMPARE_SCALAR_FIELD(override);
940 [ - + ]: 1245326 : COMPARE_NODE_FIELD(onConflict);
941 [ + + + - : 1245326 : COMPARE_STRING_FIELD(returningOldAlias);
- + ]
942 [ + + + - : 1245326 : COMPARE_STRING_FIELD(returningNewAlias);
- + ]
943 [ - + ]: 1245326 : COMPARE_NODE_FIELD(returningList);
944 [ - + ]: 1245326 : COMPARE_NODE_FIELD(groupClause);
945 [ - + ]: 1245326 : COMPARE_SCALAR_FIELD(groupDistinct);
946 [ - + ]: 1245326 : COMPARE_NODE_FIELD(groupingSets);
947 [ - + ]: 1245326 : COMPARE_NODE_FIELD(havingQual);
948 [ + + ]: 1245326 : COMPARE_NODE_FIELD(windowClause);
949 [ - + ]: 1245306 : COMPARE_NODE_FIELD(distinctClause);
950 [ - + ]: 1245306 : COMPARE_NODE_FIELD(sortClause);
951 [ - + ]: 1245306 : COMPARE_NODE_FIELD(limitOffset);
952 [ - + ]: 1245306 : COMPARE_NODE_FIELD(limitCount);
953 [ - + ]: 1245306 : COMPARE_SCALAR_FIELD(limitOption);
954 [ - + ]: 1245306 : COMPARE_NODE_FIELD(rowMarks);
955 [ - + ]: 1245306 : COMPARE_NODE_FIELD(setOperations);
956 [ - + ]: 1245306 : COMPARE_NODE_FIELD(constraintDeps);
957 [ - + ]: 1245306 : COMPARE_NODE_FIELD(withCheckOptions);
958 : : COMPARE_LOCATION_FIELD(stmt_location);
959 : : COMPARE_LOCATION_FIELD(stmt_len);
960 : :
961 : 1245306 : return true;
962 : : }
963 : :
964 : : static bool
965 : 970078 : _equalTypeName(const TypeName *a, const TypeName *b)
966 : : {
967 [ - + ]: 970078 : COMPARE_NODE_FIELD(names);
968 [ - + ]: 970078 : COMPARE_SCALAR_FIELD(typeOid);
969 [ - + ]: 970078 : COMPARE_SCALAR_FIELD(setof);
970 [ - + ]: 970078 : COMPARE_SCALAR_FIELD(pct_type);
971 [ - + ]: 970078 : COMPARE_NODE_FIELD(typmods);
972 [ - + ]: 970078 : COMPARE_SCALAR_FIELD(typemod);
973 [ - + ]: 970078 : COMPARE_NODE_FIELD(arrayBounds);
974 : : COMPARE_LOCATION_FIELD(location);
975 : :
976 : 970078 : return true;
977 : : }
978 : :
979 : : static bool
980 : 2718080 : _equalColumnRef(const ColumnRef *a, const ColumnRef *b)
981 : : {
982 [ + + ]: 2718080 : COMPARE_NODE_FIELD(fields);
983 : : COMPARE_LOCATION_FIELD(location);
984 : :
985 : 2718052 : return true;
986 : : }
987 : :
988 : : static bool
989 : 63302 : _equalParamRef(const ParamRef *a, const ParamRef *b)
990 : : {
991 [ - + ]: 63302 : COMPARE_SCALAR_FIELD(number);
992 : : COMPARE_LOCATION_FIELD(location);
993 : :
994 : 63302 : return true;
995 : : }
996 : :
997 : : static bool
998 : 870012 : _equalA_Expr(const A_Expr *a, const A_Expr *b)
999 : : {
1000 [ - + ]: 870012 : COMPARE_SCALAR_FIELD(kind);
1001 [ - + ]: 870012 : COMPARE_NODE_FIELD(name);
1002 [ + + ]: 870012 : COMPARE_NODE_FIELD(lexpr);
1003 [ - + ]: 870004 : 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 : 870004 : return true;
1009 : : }
1010 : :
1011 : : static bool
1012 : 472850 : _equalTypeCast(const TypeCast *a, const TypeCast *b)
1013 : : {
1014 [ - + ]: 472850 : COMPARE_NODE_FIELD(arg);
1015 [ - + ]: 472850 : COMPARE_NODE_FIELD(typeName);
1016 : : COMPARE_LOCATION_FIELD(location);
1017 : :
1018 : 472850 : return true;
1019 : : }
1020 : :
1021 : : static bool
1022 : 16408 : _equalCollateClause(const CollateClause *a, const CollateClause *b)
1023 : : {
1024 [ - + ]: 16408 : COMPARE_NODE_FIELD(arg);
1025 [ - + ]: 16408 : COMPARE_NODE_FIELD(collname);
1026 : : COMPARE_LOCATION_FIELD(location);
1027 : :
1028 : 16408 : return true;
1029 : : }
1030 : :
1031 : : static bool
1032 : 58516 : _equalRoleSpec(const RoleSpec *a, const RoleSpec *b)
1033 : : {
1034 [ - + ]: 58516 : COMPARE_SCALAR_FIELD(roletype);
1035 [ + + + - : 58516 : COMPARE_STRING_FIELD(rolename);
- + ]
1036 : : COMPARE_LOCATION_FIELD(location);
1037 : :
1038 : 58516 : return true;
1039 : : }
1040 : :
1041 : : static bool
1042 : 543130 : _equalFuncCall(const FuncCall *a, const FuncCall *b)
1043 : : {
1044 [ - + ]: 543130 : COMPARE_NODE_FIELD(funcname);
1045 [ - + ]: 543130 : COMPARE_NODE_FIELD(args);
1046 [ - + ]: 543130 : COMPARE_NODE_FIELD(agg_order);
1047 [ - + ]: 543130 : COMPARE_NODE_FIELD(agg_filter);
1048 [ - + ]: 543130 : COMPARE_NODE_FIELD(over);
1049 [ - + ]: 543130 : COMPARE_SCALAR_FIELD(ignore_nulls);
1050 [ - + ]: 543130 : COMPARE_SCALAR_FIELD(agg_within_group);
1051 [ - + ]: 543130 : COMPARE_SCALAR_FIELD(agg_star);
1052 [ - + ]: 543130 : COMPARE_SCALAR_FIELD(agg_distinct);
1053 [ - + ]: 543130 : COMPARE_SCALAR_FIELD(func_variadic);
1054 : : COMPARE_LOCATION_FIELD(location);
1055 : :
1056 : 543130 : return true;
1057 : : }
1058 : :
1059 : : static bool
1060 : 95738 : _equalA_Star(const A_Star *a, const A_Star *b)
1061 : : {
1062 : :
1063 : 95738 : return true;
1064 : : }
1065 : :
1066 : : static bool
1067 : 20432 : _equalA_Indices(const A_Indices *a, const A_Indices *b)
1068 : : {
1069 [ - + ]: 20432 : COMPARE_SCALAR_FIELD(is_slice);
1070 [ - + ]: 20432 : COMPARE_NODE_FIELD(lidx);
1071 [ - + ]: 20432 : COMPARE_NODE_FIELD(uidx);
1072 : :
1073 : 20432 : return true;
1074 : : }
1075 : :
1076 : : static bool
1077 : 51112 : _equalA_Indirection(const A_Indirection *a, const A_Indirection *b)
1078 : : {
1079 [ - + ]: 51112 : COMPARE_NODE_FIELD(arg);
1080 [ - + ]: 51112 : COMPARE_NODE_FIELD(indirection);
1081 : :
1082 : 51112 : return true;
1083 : : }
1084 : :
1085 : : static bool
1086 : 10284 : _equalA_ArrayExpr(const A_ArrayExpr *a, const A_ArrayExpr *b)
1087 : : {
1088 [ - + ]: 10284 : COMPARE_NODE_FIELD(elements);
1089 : : COMPARE_LOCATION_FIELD(list_start);
1090 : : COMPARE_LOCATION_FIELD(list_end);
1091 : : COMPARE_LOCATION_FIELD(location);
1092 : :
1093 : 10284 : return true;
1094 : : }
1095 : :
1096 : : static bool
1097 : 1686646 : _equalResTarget(const ResTarget *a, const ResTarget *b)
1098 : : {
1099 [ + + + - : 1686646 : COMPARE_STRING_FIELD(name);
- + ]
1100 [ - + ]: 1686646 : COMPARE_NODE_FIELD(indirection);
1101 [ - + ]: 1686646 : COMPARE_NODE_FIELD(val);
1102 : : COMPARE_LOCATION_FIELD(location);
1103 : :
1104 : 1686646 : 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 : 151480 : _equalSortBy(const SortBy *a, const SortBy *b)
1119 : : {
1120 [ + + ]: 151480 : COMPARE_NODE_FIELD(node);
1121 [ + + ]: 151464 : COMPARE_SCALAR_FIELD(sortby_dir);
1122 [ - + ]: 151440 : COMPARE_SCALAR_FIELD(sortby_nulls);
1123 [ - + ]: 151440 : COMPARE_NODE_FIELD(useOp);
1124 : : COMPARE_LOCATION_FIELD(location);
1125 : :
1126 : 151440 : return true;
1127 : : }
1128 : :
1129 : : static bool
1130 : 6554 : _equalWindowDef(const WindowDef *a, const WindowDef *b)
1131 : : {
1132 [ + + + - : 6554 : COMPARE_STRING_FIELD(name);
- + ]
1133 [ + + + - : 6554 : COMPARE_STRING_FIELD(refname);
- + ]
1134 [ - + ]: 6554 : COMPARE_NODE_FIELD(partitionClause);
1135 [ - + ]: 6554 : COMPARE_NODE_FIELD(orderClause);
1136 [ - + ]: 6554 : COMPARE_SCALAR_FIELD(frameOptions);
1137 [ - + ]: 6554 : COMPARE_NODE_FIELD(startOffset);
1138 [ - + ]: 6554 : COMPARE_NODE_FIELD(endOffset);
1139 : : COMPARE_LOCATION_FIELD(location);
1140 : :
1141 : 6554 : return true;
1142 : : }
1143 : :
1144 : : static bool
1145 : 32902 : _equalRangeSubselect(const RangeSubselect *a, const RangeSubselect *b)
1146 : : {
1147 [ - + ]: 32902 : COMPARE_SCALAR_FIELD(lateral);
1148 [ - + ]: 32902 : COMPARE_NODE_FIELD(subquery);
1149 [ - + ]: 32902 : COMPARE_NODE_FIELD(alias);
1150 : :
1151 : 32902 : return true;
1152 : : }
1153 : :
1154 : : static bool
1155 : 66396 : _equalRangeFunction(const RangeFunction *a, const RangeFunction *b)
1156 : : {
1157 [ - + ]: 66396 : COMPARE_SCALAR_FIELD(lateral);
1158 [ - + ]: 66396 : COMPARE_SCALAR_FIELD(ordinality);
1159 [ - + ]: 66396 : COMPARE_SCALAR_FIELD(is_rowsfrom);
1160 [ - + ]: 66396 : COMPARE_NODE_FIELD(functions);
1161 [ - + ]: 66396 : COMPARE_NODE_FIELD(alias);
1162 [ - + ]: 66396 : COMPARE_NODE_FIELD(coldeflist);
1163 : :
1164 : 66396 : 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 : 990 : _equalRangeGraphTable(const RangeGraphTable *a, const RangeGraphTable *b)
1197 : : {
1198 [ - + ]: 990 : COMPARE_NODE_FIELD(graph_name);
1199 [ - + ]: 990 : COMPARE_NODE_FIELD(graph_pattern);
1200 [ - + ]: 990 : COMPARE_NODE_FIELD(columns);
1201 [ - + ]: 990 : COMPARE_NODE_FIELD(alias);
1202 : : COMPARE_LOCATION_FIELD(location);
1203 : :
1204 : 990 : 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 : 193770 : _equalColumnDef(const ColumnDef *a, const ColumnDef *b)
1221 : : {
1222 [ + + + - : 193770 : COMPARE_STRING_FIELD(colname);
- + ]
1223 [ - + ]: 193770 : COMPARE_NODE_FIELD(typeName);
1224 [ + + + - : 193770 : COMPARE_STRING_FIELD(compression);
- + ]
1225 [ - + ]: 193770 : COMPARE_SCALAR_FIELD(inhcount);
1226 [ - + ]: 193770 : COMPARE_SCALAR_FIELD(is_local);
1227 [ - + ]: 193770 : COMPARE_SCALAR_FIELD(is_not_null);
1228 [ - + ]: 193770 : COMPARE_SCALAR_FIELD(is_from_type);
1229 [ - + ]: 193770 : COMPARE_SCALAR_FIELD(storage);
1230 [ + + + - : 193770 : COMPARE_STRING_FIELD(storage_name);
- + ]
1231 [ - + ]: 193770 : COMPARE_NODE_FIELD(raw_default);
1232 [ - + ]: 193770 : COMPARE_NODE_FIELD(cooked_default);
1233 [ - + ]: 193770 : COMPARE_SCALAR_FIELD(identity);
1234 [ - + ]: 193770 : COMPARE_NODE_FIELD(identitySequence);
1235 [ - + ]: 193770 : COMPARE_SCALAR_FIELD(generated);
1236 [ - + ]: 193770 : COMPARE_NODE_FIELD(collClause);
1237 [ - + ]: 193770 : COMPARE_SCALAR_FIELD(collOid);
1238 [ - + ]: 193770 : COMPARE_NODE_FIELD(constraints);
1239 [ - + ]: 193770 : COMPARE_NODE_FIELD(fdwoptions);
1240 : : COMPARE_LOCATION_FIELD(location);
1241 : :
1242 : 193770 : return true;
1243 : : }
1244 : :
1245 : : static bool
1246 : 2132 : _equalTableLikeClause(const TableLikeClause *a, const TableLikeClause *b)
1247 : : {
1248 [ - + ]: 2132 : COMPARE_NODE_FIELD(relation);
1249 [ - + ]: 2132 : COMPARE_SCALAR_FIELD(options);
1250 [ - + ]: 2132 : COMPARE_SCALAR_FIELD(relationOid);
1251 : :
1252 : 2132 : return true;
1253 : : }
1254 : :
1255 : : static bool
1256 : 27155 : _equalIndexElem(const IndexElem *a, const IndexElem *b)
1257 : : {
1258 [ + + + - : 27155 : COMPARE_STRING_FIELD(name);
+ + ]
1259 [ - + ]: 27064 : COMPARE_NODE_FIELD(expr);
1260 [ - + - - : 27064 : COMPARE_STRING_FIELD(indexcolname);
- + ]
1261 [ - + ]: 27064 : COMPARE_NODE_FIELD(collation);
1262 [ - + ]: 27064 : COMPARE_NODE_FIELD(opclass);
1263 [ - + ]: 27064 : COMPARE_NODE_FIELD(opclassopts);
1264 [ - + ]: 27064 : COMPARE_SCALAR_FIELD(ordering);
1265 [ - + ]: 27064 : COMPARE_SCALAR_FIELD(nulls_ordering);
1266 : : COMPARE_LOCATION_FIELD(location);
1267 : :
1268 : 27064 : return true;
1269 : : }
1270 : :
1271 : : static bool
1272 : 403864 : _equalDefElem(const DefElem *a, const DefElem *b)
1273 : : {
1274 [ + + + - : 403864 : COMPARE_STRING_FIELD(defnamespace);
- + ]
1275 [ + - + - : 403864 : COMPARE_STRING_FIELD(defname);
- + ]
1276 [ - + ]: 403864 : COMPARE_NODE_FIELD(arg);
1277 [ - + ]: 403864 : COMPARE_SCALAR_FIELD(defaction);
1278 : : COMPARE_LOCATION_FIELD(location);
1279 : :
1280 : 403864 : return true;
1281 : : }
1282 : :
1283 : : static bool
1284 : 8100 : _equalLockingClause(const LockingClause *a, const LockingClause *b)
1285 : : {
1286 [ - + ]: 8100 : COMPARE_NODE_FIELD(lockedRels);
1287 [ - + ]: 8100 : COMPARE_SCALAR_FIELD(strength);
1288 [ - + ]: 8100 : COMPARE_SCALAR_FIELD(waitPolicy);
1289 : :
1290 : 8100 : 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 : 16088 : _equalPartitionElem(const PartitionElem *a, const PartitionElem *b)
1307 : : {
1308 [ + + + - : 16088 : COMPARE_STRING_FIELD(name);
- + ]
1309 [ - + ]: 16088 : COMPARE_NODE_FIELD(expr);
1310 [ - + ]: 16088 : COMPARE_NODE_FIELD(collation);
1311 [ - + ]: 16088 : COMPARE_NODE_FIELD(opclass);
1312 : : COMPARE_LOCATION_FIELD(location);
1313 : :
1314 : 16088 : return true;
1315 : : }
1316 : :
1317 : : static bool
1318 : 14800 : _equalPartitionSpec(const PartitionSpec *a, const PartitionSpec *b)
1319 : : {
1320 [ - + ]: 14800 : COMPARE_SCALAR_FIELD(strategy);
1321 [ - + ]: 14800 : COMPARE_NODE_FIELD(partParams);
1322 : : COMPARE_LOCATION_FIELD(location);
1323 : :
1324 : 14800 : return true;
1325 : : }
1326 : :
1327 : : static bool
1328 : 35004 : _equalPartitionBoundSpec(const PartitionBoundSpec *a, const PartitionBoundSpec *b)
1329 : : {
1330 [ - + ]: 35004 : COMPARE_SCALAR_FIELD(strategy);
1331 [ - + ]: 35004 : COMPARE_SCALAR_FIELD(is_default);
1332 [ - + ]: 35004 : COMPARE_SCALAR_FIELD(modulus);
1333 [ - + ]: 35004 : COMPARE_SCALAR_FIELD(remainder);
1334 [ - + ]: 35004 : COMPARE_NODE_FIELD(listdatums);
1335 [ - + ]: 35004 : COMPARE_NODE_FIELD(lowerdatums);
1336 [ - + ]: 35004 : COMPARE_NODE_FIELD(upperdatums);
1337 : : COMPARE_LOCATION_FIELD(location);
1338 : :
1339 : 35004 : 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 : 996 : _equalGraphPattern(const GraphPattern *a, const GraphPattern *b)
1374 : : {
1375 [ - + ]: 996 : COMPARE_NODE_FIELD(path_pattern_list);
1376 [ - + ]: 996 : COMPARE_NODE_FIELD(whereClause);
1377 : :
1378 : 996 : return true;
1379 : : }
1380 : :
1381 : : static bool
1382 : 2892 : _equalGraphElementPattern(const GraphElementPattern *a, const GraphElementPattern *b)
1383 : : {
1384 [ - + ]: 2892 : COMPARE_SCALAR_FIELD(kind);
1385 [ + + + - : 2892 : COMPARE_STRING_FIELD(variable);
- + ]
1386 [ - + ]: 2892 : COMPARE_NODE_FIELD(labelexpr);
1387 [ - + ]: 2892 : COMPARE_NODE_FIELD(subexpr);
1388 [ - + ]: 2892 : COMPARE_NODE_FIELD(whereClause);
1389 [ - + ]: 2892 : COMPARE_NODE_FIELD(quantifier);
1390 : : COMPARE_LOCATION_FIELD(location);
1391 : :
1392 : 2892 : return true;
1393 : : }
1394 : :
1395 : : static bool
1396 : 935923 : _equalRangeTblEntry(const RangeTblEntry *a, const RangeTblEntry *b)
1397 : : {
1398 [ + + ]: 935923 : COMPARE_NODE_FIELD(alias);
1399 [ - + ]: 935912 : COMPARE_NODE_FIELD(eref);
1400 [ - + ]: 935912 : COMPARE_SCALAR_FIELD(rtekind);
1401 [ - + ]: 935912 : COMPARE_SCALAR_FIELD(relid);
1402 [ - + ]: 935912 : COMPARE_SCALAR_FIELD(inh);
1403 [ - + ]: 935912 : COMPARE_SCALAR_FIELD(relkind);
1404 [ - + ]: 935912 : COMPARE_SCALAR_FIELD(rellockmode);
1405 [ - + ]: 935912 : COMPARE_SCALAR_FIELD(perminfoindex);
1406 [ - + ]: 935912 : COMPARE_NODE_FIELD(tablesample);
1407 [ + + ]: 935912 : COMPARE_NODE_FIELD(subquery);
1408 [ - + ]: 935904 : COMPARE_SCALAR_FIELD(security_barrier);
1409 [ - + ]: 935904 : COMPARE_SCALAR_FIELD(jointype);
1410 [ - + ]: 935904 : COMPARE_SCALAR_FIELD(joinmergedcols);
1411 [ - + ]: 935904 : COMPARE_NODE_FIELD(joinaliasvars);
1412 [ - + ]: 935904 : COMPARE_NODE_FIELD(joinleftcols);
1413 [ - + ]: 935904 : COMPARE_NODE_FIELD(joinrightcols);
1414 [ - + ]: 935904 : COMPARE_NODE_FIELD(join_using_alias);
1415 [ - + ]: 935904 : COMPARE_NODE_FIELD(functions);
1416 [ - + ]: 935904 : COMPARE_SCALAR_FIELD(funcordinality);
1417 [ - + ]: 935904 : COMPARE_NODE_FIELD(tablefunc);
1418 [ - + ]: 935904 : COMPARE_NODE_FIELD(graph_pattern);
1419 [ - + ]: 935904 : COMPARE_NODE_FIELD(graph_table_columns);
1420 [ - + ]: 935904 : COMPARE_NODE_FIELD(values_lists);
1421 [ + + + - : 935904 : COMPARE_STRING_FIELD(ctename);
- + ]
1422 [ - + ]: 935904 : COMPARE_SCALAR_FIELD(ctelevelsup);
1423 [ - + ]: 935904 : COMPARE_SCALAR_FIELD(self_reference);
1424 [ - + ]: 935904 : COMPARE_NODE_FIELD(coltypes);
1425 [ - + ]: 935904 : COMPARE_NODE_FIELD(coltypmods);
1426 [ - + ]: 935904 : COMPARE_NODE_FIELD(colcollations);
1427 [ + + + - : 935904 : COMPARE_STRING_FIELD(enrname);
- + ]
1428 [ - + ]: 935904 : COMPARE_SCALAR_FIELD(enrtuples);
1429 [ - + ]: 935904 : COMPARE_NODE_FIELD(groupexprs);
1430 [ - + ]: 935904 : COMPARE_SCALAR_FIELD(lateral);
1431 [ - + ]: 935904 : COMPARE_SCALAR_FIELD(inFromCl);
1432 [ - + ]: 935904 : COMPARE_NODE_FIELD(securityQuals);
1433 : :
1434 : 935904 : return true;
1435 : : }
1436 : :
1437 : : static bool
1438 : 642341 : _equalRTEPermissionInfo(const RTEPermissionInfo *a, const RTEPermissionInfo *b)
1439 : : {
1440 [ - + ]: 642341 : COMPARE_SCALAR_FIELD(relid);
1441 [ - + ]: 642341 : COMPARE_SCALAR_FIELD(inh);
1442 [ - + ]: 642341 : COMPARE_SCALAR_FIELD(requiredPerms);
1443 [ + + ]: 642341 : COMPARE_SCALAR_FIELD(checkAsUser);
1444 [ - + ]: 642308 : COMPARE_BITMAPSET_FIELD(selectedCols);
1445 [ - + ]: 642308 : COMPARE_BITMAPSET_FIELD(insertedCols);
1446 [ - + ]: 642308 : COMPARE_BITMAPSET_FIELD(updatedCols);
1447 : :
1448 : 642308 : return true;
1449 : : }
1450 : :
1451 : : static bool
1452 : 61508 : _equalRangeTblFunction(const RangeTblFunction *a, const RangeTblFunction *b)
1453 : : {
1454 [ - + ]: 61508 : COMPARE_NODE_FIELD(funcexpr);
1455 [ - + ]: 61508 : COMPARE_SCALAR_FIELD(funccolcount);
1456 [ - + ]: 61508 : COMPARE_NODE_FIELD(funccolnames);
1457 [ - + ]: 61508 : COMPARE_NODE_FIELD(funccoltypes);
1458 [ - + ]: 61508 : COMPARE_NODE_FIELD(funccoltypmods);
1459 [ - + ]: 61508 : COMPARE_NODE_FIELD(funccolcollations);
1460 [ - + ]: 61508 : COMPARE_BITMAPSET_FIELD(funcparams);
1461 : :
1462 : 61508 : 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 : 6941 : _equalWithCheckOption(const WithCheckOption *a, const WithCheckOption *b)
1477 : : {
1478 [ + + ]: 6941 : COMPARE_SCALAR_FIELD(kind);
1479 [ + - + - : 4845 : COMPARE_STRING_FIELD(relname);
- + ]
1480 [ + + + + : 4845 : COMPARE_STRING_FIELD(polname);
+ + ]
1481 [ + + ]: 4700 : COMPARE_NODE_FIELD(qual);
1482 [ - + ]: 4248 : COMPARE_SCALAR_FIELD(cascaded);
1483 : :
1484 : 4248 : return true;
1485 : : }
1486 : :
1487 : : static bool
1488 : 206978 : _equalSortGroupClause(const SortGroupClause *a, const SortGroupClause *b)
1489 : : {
1490 [ + + ]: 206978 : COMPARE_SCALAR_FIELD(tleSortGroupRef);
1491 [ - + ]: 205446 : COMPARE_SCALAR_FIELD(eqop);
1492 [ + + ]: 205446 : COMPARE_SCALAR_FIELD(sortop);
1493 [ - + ]: 205406 : COMPARE_SCALAR_FIELD(reverse_sort);
1494 [ + + ]: 205406 : COMPARE_SCALAR_FIELD(nulls_first);
1495 [ - + ]: 205401 : COMPARE_SCALAR_FIELD(hashable);
1496 : :
1497 : 205401 : 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 : 4194 : _equalWindowClause(const WindowClause *a, const WindowClause *b)
1512 : : {
1513 [ + + + - : 4194 : COMPARE_STRING_FIELD(name);
- + ]
1514 [ + + + - : 4194 : COMPARE_STRING_FIELD(refname);
- + ]
1515 [ - + ]: 4194 : COMPARE_NODE_FIELD(partitionClause);
1516 [ - + ]: 4194 : COMPARE_NODE_FIELD(orderClause);
1517 [ + + ]: 4194 : COMPARE_SCALAR_FIELD(frameOptions);
1518 [ - + ]: 4174 : COMPARE_NODE_FIELD(startOffset);
1519 [ - + ]: 4174 : COMPARE_NODE_FIELD(endOffset);
1520 [ - + ]: 4174 : COMPARE_SCALAR_FIELD(startInRangeFunc);
1521 [ - + ]: 4174 : COMPARE_SCALAR_FIELD(endInRangeFunc);
1522 [ - + ]: 4174 : COMPARE_SCALAR_FIELD(inRangeColl);
1523 [ - + ]: 4174 : COMPARE_SCALAR_FIELD(inRangeAsc);
1524 [ - + ]: 4174 : COMPARE_SCALAR_FIELD(inRangeNullsFirst);
1525 [ - + ]: 4174 : COMPARE_SCALAR_FIELD(winref);
1526 [ - + ]: 4174 : COMPARE_SCALAR_FIELD(copiedOrder);
1527 : :
1528 : 4174 : return true;
1529 : : }
1530 : :
1531 : : static bool
1532 : 10200 : _equalRowMarkClause(const RowMarkClause *a, const RowMarkClause *b)
1533 : : {
1534 [ - + ]: 10200 : COMPARE_SCALAR_FIELD(rti);
1535 [ - + ]: 10200 : COMPARE_SCALAR_FIELD(strength);
1536 [ - + ]: 10200 : COMPARE_SCALAR_FIELD(waitPolicy);
1537 [ - + ]: 10200 : COMPARE_SCALAR_FIELD(pushedDown);
1538 : :
1539 : 10200 : return true;
1540 : : }
1541 : :
1542 : : static bool
1543 : 2378 : _equalForPortionOfClause(const ForPortionOfClause *a, const ForPortionOfClause *b)
1544 : : {
1545 [ + - + - : 2378 : COMPARE_STRING_FIELD(range_name);
- + ]
1546 : : COMPARE_LOCATION_FIELD(location);
1547 : : COMPARE_LOCATION_FIELD(target_location);
1548 [ - + ]: 2378 : COMPARE_NODE_FIELD(target);
1549 [ - + ]: 2378 : COMPARE_NODE_FIELD(target_start);
1550 [ - + ]: 2378 : COMPARE_NODE_FIELD(target_end);
1551 : :
1552 : 2378 : return true;
1553 : : }
1554 : :
1555 : : static bool
1556 : 4516 : _equalWithClause(const WithClause *a, const WithClause *b)
1557 : : {
1558 [ - + ]: 4516 : COMPARE_NODE_FIELD(ctes);
1559 [ - + ]: 4516 : COMPARE_SCALAR_FIELD(recursive);
1560 : : COMPARE_LOCATION_FIELD(location);
1561 : :
1562 : 4516 : 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 : 11310 : _equalCommonTableExpr(const CommonTableExpr *a, const CommonTableExpr *b)
1619 : : {
1620 [ + - + - : 11310 : COMPARE_STRING_FIELD(ctename);
- + ]
1621 [ - + ]: 11310 : COMPARE_NODE_FIELD(aliascolnames);
1622 [ - + ]: 11310 : COMPARE_SCALAR_FIELD(ctematerialized);
1623 [ + + ]: 11310 : COMPARE_NODE_FIELD(ctequery);
1624 [ - + ]: 11306 : COMPARE_NODE_FIELD(search_clause);
1625 [ - + ]: 11306 : COMPARE_NODE_FIELD(cycle_clause);
1626 : : COMPARE_LOCATION_FIELD(location);
1627 [ - + ]: 11306 : COMPARE_SCALAR_FIELD(cterecursive);
1628 [ - + ]: 11306 : COMPARE_SCALAR_FIELD(cterefcount);
1629 [ - + ]: 11306 : COMPARE_NODE_FIELD(ctecolnames);
1630 [ - + ]: 11306 : COMPARE_NODE_FIELD(ctecoltypes);
1631 [ - + ]: 11306 : COMPARE_NODE_FIELD(ctecoltypmods);
1632 [ - + ]: 11306 : COMPARE_NODE_FIELD(ctecolcollations);
1633 : :
1634 : 11306 : 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 : 5020 : _equalReturningClause(const ReturningClause *a, const ReturningClause *b)
1662 : : {
1663 [ - + ]: 5020 : COMPARE_NODE_FIELD(options);
1664 [ - + ]: 5020 : COMPARE_NODE_FIELD(exprs);
1665 : :
1666 : 5020 : 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 : 947876 : _equalRawStmt(const RawStmt *a, const RawStmt *b)
1883 : : {
1884 [ - + ]: 947876 : COMPARE_NODE_FIELD(stmt);
1885 : : COMPARE_LOCATION_FIELD(stmt_location);
1886 : : COMPARE_LOCATION_FIELD(stmt_len);
1887 : :
1888 : 947876 : return true;
1889 : : }
1890 : :
1891 : : static bool
1892 : 90658 : _equalInsertStmt(const InsertStmt *a, const InsertStmt *b)
1893 : : {
1894 [ - + ]: 90658 : COMPARE_NODE_FIELD(relation);
1895 [ - + ]: 90658 : COMPARE_NODE_FIELD(cols);
1896 [ - + ]: 90658 : COMPARE_NODE_FIELD(selectStmt);
1897 [ - + ]: 90658 : COMPARE_NODE_FIELD(onConflictClause);
1898 [ - + ]: 90658 : COMPARE_NODE_FIELD(returningClause);
1899 [ - + ]: 90658 : COMPARE_NODE_FIELD(withClause);
1900 [ - + ]: 90658 : COMPARE_SCALAR_FIELD(override);
1901 : :
1902 : 90658 : return true;
1903 : : }
1904 : :
1905 : : static bool
1906 : 6858 : _equalDeleteStmt(const DeleteStmt *a, const DeleteStmt *b)
1907 : : {
1908 [ - + ]: 6858 : COMPARE_NODE_FIELD(relation);
1909 [ - + ]: 6858 : COMPARE_NODE_FIELD(usingClause);
1910 [ - + ]: 6858 : COMPARE_NODE_FIELD(whereClause);
1911 [ - + ]: 6858 : COMPARE_NODE_FIELD(returningClause);
1912 [ - + ]: 6858 : COMPARE_NODE_FIELD(withClause);
1913 [ - + ]: 6858 : COMPARE_NODE_FIELD(forPortionOf);
1914 : :
1915 : 6858 : return true;
1916 : : }
1917 : :
1918 : : static bool
1919 : 18526 : _equalUpdateStmt(const UpdateStmt *a, const UpdateStmt *b)
1920 : : {
1921 [ - + ]: 18526 : COMPARE_NODE_FIELD(relation);
1922 [ - + ]: 18526 : COMPARE_NODE_FIELD(targetList);
1923 [ - + ]: 18526 : COMPARE_NODE_FIELD(whereClause);
1924 [ - + ]: 18526 : COMPARE_NODE_FIELD(fromClause);
1925 [ - + ]: 18526 : COMPARE_NODE_FIELD(returningClause);
1926 [ - + ]: 18526 : COMPARE_NODE_FIELD(withClause);
1927 [ - + ]: 18526 : COMPARE_NODE_FIELD(forPortionOf);
1928 : :
1929 : 18526 : 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 : 693432 : _equalSelectStmt(const SelectStmt *a, const SelectStmt *b)
1947 : : {
1948 [ - + ]: 693432 : COMPARE_NODE_FIELD(distinctClause);
1949 [ - + ]: 693432 : COMPARE_NODE_FIELD(intoClause);
1950 [ - + ]: 693432 : COMPARE_NODE_FIELD(targetList);
1951 [ - + ]: 693432 : COMPARE_NODE_FIELD(fromClause);
1952 [ - + ]: 693432 : COMPARE_NODE_FIELD(whereClause);
1953 [ - + ]: 693432 : COMPARE_NODE_FIELD(groupClause);
1954 [ - + ]: 693432 : COMPARE_SCALAR_FIELD(groupDistinct);
1955 [ - + ]: 693432 : COMPARE_NODE_FIELD(havingClause);
1956 [ - + ]: 693432 : COMPARE_NODE_FIELD(windowClause);
1957 [ - + ]: 693432 : COMPARE_NODE_FIELD(valuesLists);
1958 [ - + ]: 693432 : COMPARE_NODE_FIELD(sortClause);
1959 [ - + ]: 693432 : COMPARE_NODE_FIELD(limitOffset);
1960 [ - + ]: 693432 : COMPARE_NODE_FIELD(limitCount);
1961 [ - + ]: 693432 : COMPARE_SCALAR_FIELD(limitOption);
1962 [ - + ]: 693432 : COMPARE_NODE_FIELD(lockingClause);
1963 [ - + ]: 693432 : COMPARE_NODE_FIELD(withClause);
1964 [ - + ]: 693432 : COMPARE_SCALAR_FIELD(op);
1965 [ - + ]: 693432 : COMPARE_SCALAR_FIELD(all);
1966 [ - + ]: 693432 : COMPARE_NODE_FIELD(larg);
1967 [ - + ]: 693432 : COMPARE_NODE_FIELD(rarg);
1968 : :
1969 : 693432 : return true;
1970 : : }
1971 : :
1972 : : static bool
1973 : 27234 : _equalSetOperationStmt(const SetOperationStmt *a, const SetOperationStmt *b)
1974 : : {
1975 [ - + ]: 27234 : COMPARE_SCALAR_FIELD(op);
1976 [ - + ]: 27234 : COMPARE_SCALAR_FIELD(all);
1977 [ - + ]: 27234 : COMPARE_NODE_FIELD(larg);
1978 [ - + ]: 27234 : COMPARE_NODE_FIELD(rarg);
1979 [ - + ]: 27234 : COMPARE_NODE_FIELD(colTypes);
1980 [ - + ]: 27234 : COMPARE_NODE_FIELD(colTypmods);
1981 [ - + ]: 27234 : COMPARE_NODE_FIELD(colCollations);
1982 [ - + ]: 27234 : COMPARE_NODE_FIELD(groupClauses);
1983 : :
1984 : 27234 : 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 : 3094 : _equalCreateSchemaStmt(const CreateSchemaStmt *a, const CreateSchemaStmt *b)
2009 : : {
2010 [ + + + - : 3094 : COMPARE_STRING_FIELD(schemaname);
- + ]
2011 [ - + ]: 3094 : COMPARE_NODE_FIELD(authrole);
2012 [ - + ]: 3094 : COMPARE_NODE_FIELD(schemaElts);
2013 [ - + ]: 3094 : COMPARE_SCALAR_FIELD(if_not_exists);
2014 : :
2015 : 3094 : return true;
2016 : : }
2017 : :
2018 : : static bool
2019 : 83060 : _equalAlterTableStmt(const AlterTableStmt *a, const AlterTableStmt *b)
2020 : : {
2021 [ - + ]: 83060 : COMPARE_NODE_FIELD(relation);
2022 [ - + ]: 83060 : COMPARE_NODE_FIELD(cmds);
2023 [ - + ]: 83060 : COMPARE_SCALAR_FIELD(objtype);
2024 [ - + ]: 83060 : COMPARE_SCALAR_FIELD(missing_ok);
2025 : :
2026 : 83060 : return true;
2027 : : }
2028 : :
2029 : : static bool
2030 : 85880 : _equalAlterTableCmd(const AlterTableCmd *a, const AlterTableCmd *b)
2031 : : {
2032 [ - + ]: 85880 : COMPARE_SCALAR_FIELD(subtype);
2033 [ + + + - : 85880 : COMPARE_STRING_FIELD(name);
- + ]
2034 [ - + ]: 85880 : COMPARE_SCALAR_FIELD(num);
2035 [ - + ]: 85880 : COMPARE_NODE_FIELD(newowner);
2036 [ - + ]: 85880 : COMPARE_NODE_FIELD(def);
2037 [ - + ]: 85880 : COMPARE_SCALAR_FIELD(behavior);
2038 [ - + ]: 85880 : COMPARE_SCALAR_FIELD(missing_ok);
2039 [ - + ]: 85880 : COMPARE_SCALAR_FIELD(recurse);
2040 : :
2041 : 85880 : 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 : 1256 : _equalReplicaIdentityStmt(const ReplicaIdentityStmt *a, const ReplicaIdentityStmt *b)
2061 : : {
2062 [ - + ]: 1256 : COMPARE_SCALAR_FIELD(identity_type);
2063 [ + + + - : 1256 : COMPARE_STRING_FIELD(name);
- + ]
2064 : :
2065 : 1256 : 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 : 34458 : _equalGrantStmt(const GrantStmt *a, const GrantStmt *b)
2091 : : {
2092 [ - + ]: 34458 : COMPARE_SCALAR_FIELD(is_grant);
2093 [ - + ]: 34458 : COMPARE_SCALAR_FIELD(targtype);
2094 [ - + ]: 34458 : COMPARE_SCALAR_FIELD(objtype);
2095 [ - + ]: 34458 : COMPARE_NODE_FIELD(objects);
2096 [ - + ]: 34458 : COMPARE_NODE_FIELD(privileges);
2097 [ - + ]: 34458 : COMPARE_NODE_FIELD(grantees);
2098 [ - + ]: 34458 : COMPARE_SCALAR_FIELD(grant_option);
2099 [ - + ]: 34458 : COMPARE_NODE_FIELD(grantor);
2100 [ - + ]: 34458 : COMPARE_SCALAR_FIELD(behavior);
2101 : :
2102 : 34458 : return true;
2103 : : }
2104 : :
2105 : : static bool
2106 : 32808 : _equalObjectWithArgs(const ObjectWithArgs *a, const ObjectWithArgs *b)
2107 : : {
2108 [ - + ]: 32808 : COMPARE_NODE_FIELD(objname);
2109 [ - + ]: 32808 : COMPARE_NODE_FIELD(objargs);
2110 [ - + ]: 32808 : COMPARE_NODE_FIELD(objfuncargs);
2111 [ - + ]: 32808 : COMPARE_SCALAR_FIELD(args_unspecified);
2112 : :
2113 : 32808 : return true;
2114 : : }
2115 : :
2116 : : static bool
2117 : 30872 : _equalAccessPriv(const AccessPriv *a, const AccessPriv *b)
2118 : : {
2119 [ + + + - : 30872 : COMPARE_STRING_FIELD(priv_name);
- + ]
2120 [ - + ]: 30872 : COMPARE_NODE_FIELD(cols);
2121 : :
2122 : 30872 : return true;
2123 : : }
2124 : :
2125 : : static bool
2126 : 1714 : _equalGrantRoleStmt(const GrantRoleStmt *a, const GrantRoleStmt *b)
2127 : : {
2128 [ - + ]: 1714 : COMPARE_NODE_FIELD(granted_roles);
2129 [ - + ]: 1714 : COMPARE_NODE_FIELD(grantee_roles);
2130 [ - + ]: 1714 : COMPARE_SCALAR_FIELD(is_grant);
2131 [ - + ]: 1714 : COMPARE_NODE_FIELD(opt);
2132 [ - + ]: 1714 : COMPARE_NODE_FIELD(grantor);
2133 [ - + ]: 1714 : COMPARE_SCALAR_FIELD(behavior);
2134 : :
2135 : 1714 : 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 : 26858 : _equalCopyStmt(const CopyStmt *a, const CopyStmt *b)
2149 : : {
2150 [ - + ]: 26858 : COMPARE_NODE_FIELD(relation);
2151 [ - + ]: 26858 : COMPARE_NODE_FIELD(query);
2152 [ - + ]: 26858 : COMPARE_NODE_FIELD(attlist);
2153 [ - + ]: 26858 : COMPARE_SCALAR_FIELD(is_from);
2154 [ - + ]: 26858 : COMPARE_SCALAR_FIELD(is_program);
2155 [ + + + - : 26858 : COMPARE_STRING_FIELD(filename);
- + ]
2156 [ - + ]: 26858 : COMPARE_NODE_FIELD(options);
2157 [ - + ]: 26858 : COMPARE_NODE_FIELD(whereClause);
2158 : :
2159 : 26858 : return true;
2160 : : }
2161 : :
2162 : : static bool
2163 : 77366 : _equalVariableSetStmt(const VariableSetStmt *a, const VariableSetStmt *b)
2164 : : {
2165 [ - + ]: 77366 : COMPARE_SCALAR_FIELD(kind);
2166 [ + + + - : 77366 : COMPARE_STRING_FIELD(name);
- + ]
2167 [ - + ]: 77366 : COMPARE_NODE_FIELD(args);
2168 [ - + ]: 77366 : COMPARE_SCALAR_FIELD(jumble_args);
2169 [ - + ]: 77366 : COMPARE_SCALAR_FIELD(is_local);
2170 : : COMPARE_LOCATION_FIELD(location);
2171 : :
2172 : 77366 : 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 : 105772 : _equalCreateStmt(const CreateStmt *a, const CreateStmt *b)
2185 : : {
2186 [ - + ]: 105772 : COMPARE_NODE_FIELD(relation);
2187 [ - + ]: 105772 : COMPARE_NODE_FIELD(tableElts);
2188 [ - + ]: 105772 : COMPARE_NODE_FIELD(inhRelations);
2189 [ - + ]: 105772 : COMPARE_NODE_FIELD(partbound);
2190 [ - + ]: 105772 : COMPARE_NODE_FIELD(partspec);
2191 [ - + ]: 105772 : COMPARE_NODE_FIELD(ofTypename);
2192 [ - + ]: 105772 : COMPARE_NODE_FIELD(constraints);
2193 [ - + ]: 105772 : COMPARE_NODE_FIELD(nnconstraints);
2194 [ - + ]: 105772 : COMPARE_NODE_FIELD(options);
2195 [ - + ]: 105772 : COMPARE_SCALAR_FIELD(oncommit);
2196 [ + + + - : 105772 : COMPARE_STRING_FIELD(tablespacename);
- + ]
2197 [ + + + - : 105772 : COMPARE_STRING_FIELD(accessMethod);
- + ]
2198 [ - + ]: 105772 : COMPARE_SCALAR_FIELD(if_not_exists);
2199 : :
2200 : 105772 : return true;
2201 : : }
2202 : :
2203 : : static bool
2204 : 97060 : _equalConstraint(const Constraint *a, const Constraint *b)
2205 : : {
2206 [ - + ]: 97060 : COMPARE_SCALAR_FIELD(contype);
2207 [ + + + - : 97060 : COMPARE_STRING_FIELD(conname);
- + ]
2208 [ - + ]: 97060 : COMPARE_SCALAR_FIELD(deferrable);
2209 [ - + ]: 97060 : COMPARE_SCALAR_FIELD(initdeferred);
2210 [ - + ]: 97060 : COMPARE_SCALAR_FIELD(is_enforced);
2211 [ - + ]: 97060 : COMPARE_SCALAR_FIELD(skip_validation);
2212 [ - + ]: 97060 : COMPARE_SCALAR_FIELD(initially_valid);
2213 [ - + ]: 97060 : COMPARE_SCALAR_FIELD(is_no_inherit);
2214 [ - + ]: 97060 : COMPARE_NODE_FIELD(raw_expr);
2215 [ - + - - : 97060 : COMPARE_STRING_FIELD(cooked_expr);
- + ]
2216 [ - + ]: 97060 : COMPARE_SCALAR_FIELD(generated_when);
2217 [ - + ]: 97060 : COMPARE_SCALAR_FIELD(generated_kind);
2218 [ - + ]: 97060 : COMPARE_SCALAR_FIELD(nulls_not_distinct);
2219 [ - + ]: 97060 : COMPARE_NODE_FIELD(keys);
2220 [ - + ]: 97060 : COMPARE_SCALAR_FIELD(without_overlaps);
2221 [ - + ]: 97060 : COMPARE_NODE_FIELD(including);
2222 [ - + ]: 97060 : COMPARE_NODE_FIELD(exclusions);
2223 [ - + ]: 97060 : COMPARE_NODE_FIELD(options);
2224 [ + + + - : 97060 : COMPARE_STRING_FIELD(indexname);
- + ]
2225 [ + + + - : 97060 : COMPARE_STRING_FIELD(indexspace);
- + ]
2226 [ - + ]: 97060 : COMPARE_SCALAR_FIELD(reset_default_tblspc);
2227 [ + + + - : 97060 : COMPARE_STRING_FIELD(access_method);
- + ]
2228 [ - + ]: 97060 : COMPARE_NODE_FIELD(where_clause);
2229 [ - + ]: 97060 : COMPARE_NODE_FIELD(pktable);
2230 [ - + ]: 97060 : COMPARE_NODE_FIELD(fk_attrs);
2231 [ - + ]: 97060 : COMPARE_NODE_FIELD(pk_attrs);
2232 [ - + ]: 97060 : COMPARE_SCALAR_FIELD(fk_with_period);
2233 [ - + ]: 97060 : COMPARE_SCALAR_FIELD(pk_with_period);
2234 [ - + ]: 97060 : COMPARE_SCALAR_FIELD(fk_matchtype);
2235 [ - + ]: 97060 : COMPARE_SCALAR_FIELD(fk_upd_action);
2236 [ - + ]: 97060 : COMPARE_SCALAR_FIELD(fk_del_action);
2237 [ - + ]: 97060 : COMPARE_NODE_FIELD(fk_del_set_cols);
2238 [ - + ]: 97060 : COMPARE_NODE_FIELD(old_conpfeqop);
2239 [ - + ]: 97060 : COMPARE_SCALAR_FIELD(old_pktable_oid);
2240 : : COMPARE_LOCATION_FIELD(location);
2241 : :
2242 : 97060 : return true;
2243 : : }
2244 : :
2245 : : static bool
2246 : 308 : _equalCreateTableSpaceStmt(const CreateTableSpaceStmt *a, const CreateTableSpaceStmt *b)
2247 : : {
2248 [ + - + - : 308 : COMPARE_STRING_FIELD(tablespacename);
- + ]
2249 [ - + ]: 308 : COMPARE_NODE_FIELD(owner);
2250 [ + - + - : 308 : COMPARE_STRING_FIELD(location);
- + ]
2251 [ - + ]: 308 : COMPARE_NODE_FIELD(options);
2252 : :
2253 : 308 : return true;
2254 : : }
2255 : :
2256 : : static bool
2257 : 144 : _equalDropTableSpaceStmt(const DropTableSpaceStmt *a, const DropTableSpaceStmt *b)
2258 : : {
2259 [ + - + - : 144 : COMPARE_STRING_FIELD(tablespacename);
- + ]
2260 [ - + ]: 144 : COMPARE_SCALAR_FIELD(missing_ok);
2261 : :
2262 : 144 : 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 : 64 : _equalAlterTableMoveAllStmt(const AlterTableMoveAllStmt *a, const AlterTableMoveAllStmt *b)
2277 : : {
2278 [ + - + - : 64 : COMPARE_STRING_FIELD(orig_tablespacename);
- + ]
2279 [ - + ]: 64 : COMPARE_SCALAR_FIELD(objtype);
2280 [ - + ]: 64 : COMPARE_NODE_FIELD(roles);
2281 [ + - + - : 64 : COMPARE_STRING_FIELD(new_tablespacename);
- + ]
2282 [ - + ]: 64 : COMPARE_SCALAR_FIELD(nowait);
2283 : :
2284 : 64 : return true;
2285 : : }
2286 : :
2287 : : static bool
2288 : 1340 : _equalCreateExtensionStmt(const CreateExtensionStmt *a, const CreateExtensionStmt *b)
2289 : : {
2290 [ + - + - : 1340 : COMPARE_STRING_FIELD(extname);
- + ]
2291 [ - + ]: 1340 : COMPARE_SCALAR_FIELD(if_not_exists);
2292 [ - + ]: 1340 : COMPARE_NODE_FIELD(options);
2293 : :
2294 : 1340 : 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 : 412 : _equalAlterFdwStmt(const AlterFdwStmt *a, const AlterFdwStmt *b)
2329 : : {
2330 [ + - + - : 412 : COMPARE_STRING_FIELD(fdwname);
- + ]
2331 [ - + ]: 412 : COMPARE_NODE_FIELD(func_options);
2332 [ - + ]: 412 : COMPARE_NODE_FIELD(options);
2333 : :
2334 : 412 : 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 : 668 : _equalCreateUserMappingStmt(const CreateUserMappingStmt *a, const CreateUserMappingStmt *b)
2385 : : {
2386 [ - + ]: 668 : COMPARE_NODE_FIELD(user);
2387 [ + - + - : 668 : COMPARE_STRING_FIELD(servername);
- + ]
2388 [ - + ]: 668 : COMPARE_SCALAR_FIELD(if_not_exists);
2389 [ - + ]: 668 : COMPARE_NODE_FIELD(options);
2390 : :
2391 : 668 : return true;
2392 : : }
2393 : :
2394 : : static bool
2395 : 292 : _equalAlterUserMappingStmt(const AlterUserMappingStmt *a, const AlterUserMappingStmt *b)
2396 : : {
2397 [ - + ]: 292 : COMPARE_NODE_FIELD(user);
2398 [ + - + - : 292 : COMPARE_STRING_FIELD(servername);
- + ]
2399 [ - + ]: 292 : COMPARE_NODE_FIELD(options);
2400 : :
2401 : 292 : return true;
2402 : : }
2403 : :
2404 : : static bool
2405 : 316 : _equalDropUserMappingStmt(const DropUserMappingStmt *a, const DropUserMappingStmt *b)
2406 : : {
2407 [ - + ]: 316 : COMPARE_NODE_FIELD(user);
2408 [ + - + - : 316 : COMPARE_STRING_FIELD(servername);
- + ]
2409 [ - + ]: 316 : COMPARE_SCALAR_FIELD(missing_ok);
2410 : :
2411 : 316 : 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 : 2444 : _equalCreatePolicyStmt(const CreatePolicyStmt *a, const CreatePolicyStmt *b)
2429 : : {
2430 [ + - + - : 2444 : COMPARE_STRING_FIELD(policy_name);
- + ]
2431 [ - + ]: 2444 : COMPARE_NODE_FIELD(table);
2432 [ + - + - : 2444 : COMPARE_STRING_FIELD(cmd_name);
- + ]
2433 [ - + ]: 2444 : COMPARE_SCALAR_FIELD(permissive);
2434 [ - + ]: 2444 : COMPARE_NODE_FIELD(roles);
2435 [ - + ]: 2444 : COMPARE_NODE_FIELD(qual);
2436 [ - + ]: 2444 : COMPARE_NODE_FIELD(with_check);
2437 : :
2438 : 2444 : 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 : 5268 : _equalCreateRoleStmt(const CreateRoleStmt *a, const CreateRoleStmt *b)
2520 : : {
2521 [ - + ]: 5268 : COMPARE_SCALAR_FIELD(stmt_type);
2522 [ + - + - : 5268 : COMPARE_STRING_FIELD(role);
- + ]
2523 [ - + ]: 5268 : COMPARE_NODE_FIELD(options);
2524 : :
2525 : 5268 : return true;
2526 : : }
2527 : :
2528 : : static bool
2529 : 1176 : _equalAlterRoleStmt(const AlterRoleStmt *a, const AlterRoleStmt *b)
2530 : : {
2531 [ - + ]: 1176 : COMPARE_NODE_FIELD(role);
2532 [ - + ]: 1176 : COMPARE_NODE_FIELD(options);
2533 [ - + ]: 1176 : COMPARE_SCALAR_FIELD(action);
2534 : :
2535 : 1176 : 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 : 5036 : _equalDropRoleStmt(const DropRoleStmt *a, const DropRoleStmt *b)
2550 : : {
2551 [ - + ]: 5036 : COMPARE_NODE_FIELD(roles);
2552 [ - + ]: 5036 : COMPARE_SCALAR_FIELD(missing_ok);
2553 : :
2554 : 5036 : 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 : 4068 : _equalCreateDomainStmt(const CreateDomainStmt *a, const CreateDomainStmt *b)
2596 : : {
2597 [ - + ]: 4068 : COMPARE_NODE_FIELD(domainname);
2598 [ - + ]: 4068 : COMPARE_NODE_FIELD(typeName);
2599 [ - + ]: 4068 : COMPARE_NODE_FIELD(collClause);
2600 [ - + ]: 4068 : COMPARE_NODE_FIELD(constraints);
2601 : :
2602 : 4068 : 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 : 72498 : _equalDropStmt(const DropStmt *a, const DropStmt *b)
2653 : : {
2654 [ - + ]: 72498 : COMPARE_NODE_FIELD(objects);
2655 [ - + ]: 72498 : COMPARE_SCALAR_FIELD(removeType);
2656 [ - + ]: 72498 : COMPARE_SCALAR_FIELD(behavior);
2657 [ - + ]: 72498 : COMPARE_SCALAR_FIELD(missing_ok);
2658 [ - + ]: 72498 : COMPARE_SCALAR_FIELD(concurrent);
2659 : :
2660 : 72498 : return true;
2661 : : }
2662 : :
2663 : : static bool
2664 : 4744 : _equalTruncateStmt(const TruncateStmt *a, const TruncateStmt *b)
2665 : : {
2666 [ - + ]: 4744 : COMPARE_NODE_FIELD(relations);
2667 [ - + ]: 4744 : COMPARE_SCALAR_FIELD(restart_seqs);
2668 [ - + ]: 4744 : COMPARE_SCALAR_FIELD(behavior);
2669 : :
2670 : 4744 : 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 : 8724 : _equalDeclareCursorStmt(const DeclareCursorStmt *a, const DeclareCursorStmt *b)
2696 : : {
2697 [ + - + - : 8724 : COMPARE_STRING_FIELD(portalname);
- + ]
2698 [ - + ]: 8724 : COMPARE_SCALAR_FIELD(options);
2699 [ - + ]: 8724 : COMPARE_NODE_FIELD(query);
2700 : :
2701 : 8724 : return true;
2702 : : }
2703 : :
2704 : : static bool
2705 : 4772 : _equalClosePortalStmt(const ClosePortalStmt *a, const ClosePortalStmt *b)
2706 : : {
2707 [ + + + - : 4772 : COMPARE_STRING_FIELD(portalname);
- + ]
2708 : :
2709 : 4772 : return true;
2710 : : }
2711 : :
2712 : : static bool
2713 : 15520 : _equalFetchStmt(const FetchStmt *a, const FetchStmt *b)
2714 : : {
2715 [ - + ]: 15520 : COMPARE_SCALAR_FIELD(direction);
2716 [ - + ]: 15520 : COMPARE_SCALAR_FIELD(howMany);
2717 [ + - + - : 15520 : COMPARE_STRING_FIELD(portalname);
- + ]
2718 [ - + ]: 15520 : COMPARE_SCALAR_FIELD(ismove);
2719 [ - + ]: 15520 : COMPARE_SCALAR_FIELD(direction_keyword);
2720 : : COMPARE_LOCATION_FIELD(location);
2721 : :
2722 : 15520 : return true;
2723 : : }
2724 : :
2725 : : static bool
2726 : 17606 : _equalIndexStmt(const IndexStmt *a, const IndexStmt *b)
2727 : : {
2728 [ + + + - : 17606 : COMPARE_STRING_FIELD(idxname);
- + ]
2729 [ - + ]: 17606 : COMPARE_NODE_FIELD(relation);
2730 [ + - + - : 17606 : COMPARE_STRING_FIELD(accessMethod);
- + ]
2731 [ + + + - : 17606 : COMPARE_STRING_FIELD(tableSpace);
- + ]
2732 [ - + ]: 17606 : COMPARE_NODE_FIELD(indexParams);
2733 [ - + ]: 17606 : COMPARE_NODE_FIELD(indexIncludingParams);
2734 [ - + ]: 17606 : COMPARE_NODE_FIELD(options);
2735 [ - + ]: 17606 : COMPARE_NODE_FIELD(whereClause);
2736 [ - + ]: 17606 : COMPARE_NODE_FIELD(excludeOpNames);
2737 [ - + - - : 17606 : COMPARE_STRING_FIELD(idxcomment);
- + ]
2738 [ - + ]: 17606 : COMPARE_SCALAR_FIELD(indexOid);
2739 [ - + ]: 17606 : COMPARE_SCALAR_FIELD(oldNumber);
2740 [ - + ]: 17606 : COMPARE_SCALAR_FIELD(oldCreateSubid);
2741 [ - + ]: 17606 : COMPARE_SCALAR_FIELD(oldFirstRelfilelocatorSubid);
2742 [ - + ]: 17606 : COMPARE_SCALAR_FIELD(unique);
2743 [ - + ]: 17606 : COMPARE_SCALAR_FIELD(nulls_not_distinct);
2744 [ - + ]: 17606 : COMPARE_SCALAR_FIELD(primary);
2745 [ - + ]: 17606 : COMPARE_SCALAR_FIELD(isconstraint);
2746 [ - + ]: 17606 : COMPARE_SCALAR_FIELD(iswithoutoverlaps);
2747 [ - + ]: 17606 : COMPARE_SCALAR_FIELD(deferrable);
2748 [ - + ]: 17606 : COMPARE_SCALAR_FIELD(initdeferred);
2749 [ - + ]: 17606 : COMPARE_SCALAR_FIELD(transformed);
2750 [ - + ]: 17606 : COMPARE_SCALAR_FIELD(concurrent);
2751 [ - + ]: 17606 : COMPARE_SCALAR_FIELD(if_not_exists);
2752 [ - + ]: 17606 : COMPARE_SCALAR_FIELD(reset_default_tblspc);
2753 : :
2754 : 17606 : return true;
2755 : : }
2756 : :
2757 : : static bool
2758 : 2472 : _equalCreateStatsStmt(const CreateStatsStmt *a, const CreateStatsStmt *b)
2759 : : {
2760 [ - + ]: 2472 : COMPARE_NODE_FIELD(defnames);
2761 [ - + ]: 2472 : COMPARE_NODE_FIELD(stat_types);
2762 [ - + ]: 2472 : COMPARE_NODE_FIELD(exprs);
2763 [ - + ]: 2472 : COMPARE_NODE_FIELD(relations);
2764 [ - + - - : 2472 : COMPARE_STRING_FIELD(stxcomment);
- + ]
2765 [ - + ]: 2472 : COMPARE_SCALAR_FIELD(transformed);
2766 [ - + ]: 2472 : COMPARE_SCALAR_FIELD(if_not_exists);
2767 [ - + ]: 2472 : COMPARE_SCALAR_FIELD(owner);
2768 : :
2769 : 2472 : return true;
2770 : : }
2771 : :
2772 : : static bool
2773 : 5808 : _equalStatsElem(const StatsElem *a, const StatsElem *b)
2774 : : {
2775 [ + + + - : 5808 : COMPARE_STRING_FIELD(name);
- + ]
2776 [ - + ]: 5808 : COMPARE_NODE_FIELD(expr);
2777 : :
2778 : 5808 : return true;
2779 : : }
2780 : :
2781 : : static bool
2782 : 68 : _equalAlterStatsStmt(const AlterStatsStmt *a, const AlterStatsStmt *b)
2783 : : {
2784 [ - + ]: 68 : COMPARE_NODE_FIELD(defnames);
2785 [ - + ]: 68 : COMPARE_NODE_FIELD(stxstattarget);
2786 [ - + ]: 68 : COMPARE_SCALAR_FIELD(missing_ok);
2787 : :
2788 : 68 : return true;
2789 : : }
2790 : :
2791 : : static bool
2792 : 52738 : _equalCreateFunctionStmt(const CreateFunctionStmt *a, const CreateFunctionStmt *b)
2793 : : {
2794 [ - + ]: 52738 : COMPARE_SCALAR_FIELD(is_procedure);
2795 [ - + ]: 52738 : COMPARE_SCALAR_FIELD(replace);
2796 [ - + ]: 52738 : COMPARE_NODE_FIELD(funcname);
2797 [ - + ]: 52738 : COMPARE_NODE_FIELD(parameters);
2798 [ - + ]: 52738 : COMPARE_NODE_FIELD(returnType);
2799 [ - + ]: 52738 : COMPARE_NODE_FIELD(options);
2800 [ - + ]: 52738 : COMPARE_NODE_FIELD(sql_body);
2801 : :
2802 : 52738 : return true;
2803 : : }
2804 : :
2805 : : static bool
2806 : 135992 : _equalFunctionParameter(const FunctionParameter *a, const FunctionParameter *b)
2807 : : {
2808 [ + + + - : 135992 : COMPARE_STRING_FIELD(name);
- + ]
2809 [ - + ]: 135992 : COMPARE_NODE_FIELD(argType);
2810 [ - + ]: 135992 : COMPARE_SCALAR_FIELD(mode);
2811 [ - + ]: 135992 : COMPARE_NODE_FIELD(defexpr);
2812 : : COMPARE_LOCATION_FIELD(location);
2813 : :
2814 : 135992 : return true;
2815 : : }
2816 : :
2817 : : static bool
2818 : 836 : _equalAlterFunctionStmt(const AlterFunctionStmt *a, const AlterFunctionStmt *b)
2819 : : {
2820 [ - + ]: 836 : COMPARE_SCALAR_FIELD(objtype);
2821 [ - + ]: 836 : COMPARE_NODE_FIELD(func);
2822 [ - + ]: 836 : COMPARE_NODE_FIELD(actions);
2823 : :
2824 : 836 : return true;
2825 : : }
2826 : :
2827 : : static bool
2828 : 2620 : _equalDoStmt(const DoStmt *a, const DoStmt *b)
2829 : : {
2830 [ - + ]: 2620 : COMPARE_NODE_FIELD(args);
2831 : :
2832 : 2620 : return true;
2833 : : }
2834 : :
2835 : : static bool
2836 : 1104 : _equalCallStmt(const CallStmt *a, const CallStmt *b)
2837 : : {
2838 [ - + ]: 1104 : COMPARE_NODE_FIELD(funccall);
2839 [ - + ]: 1104 : COMPARE_NODE_FIELD(funcexpr);
2840 [ - + ]: 1104 : COMPARE_NODE_FIELD(outargs);
2841 : :
2842 : 1104 : return true;
2843 : : }
2844 : :
2845 : : static bool
2846 : 3904 : _equalRenameStmt(const RenameStmt *a, const RenameStmt *b)
2847 : : {
2848 [ - + ]: 3904 : COMPARE_SCALAR_FIELD(renameType);
2849 [ - + ]: 3904 : COMPARE_SCALAR_FIELD(relationType);
2850 [ - + ]: 3904 : COMPARE_NODE_FIELD(relation);
2851 [ - + ]: 3904 : COMPARE_NODE_FIELD(object);
2852 [ + + + - : 3904 : COMPARE_STRING_FIELD(subname);
- + ]
2853 [ + - + - : 3904 : COMPARE_STRING_FIELD(newname);
- + ]
2854 [ - + ]: 3904 : COMPARE_SCALAR_FIELD(behavior);
2855 [ - + ]: 3904 : COMPARE_SCALAR_FIELD(missing_ok);
2856 : :
2857 : 3904 : return true;
2858 : : }
2859 : :
2860 : : static bool
2861 : 140 : _equalAlterObjectDependsStmt(const AlterObjectDependsStmt *a, const AlterObjectDependsStmt *b)
2862 : : {
2863 [ - + ]: 140 : COMPARE_SCALAR_FIELD(objectType);
2864 [ - + ]: 140 : COMPARE_NODE_FIELD(relation);
2865 [ - + ]: 140 : COMPARE_NODE_FIELD(object);
2866 [ - + ]: 140 : COMPARE_NODE_FIELD(extname);
2867 [ - + ]: 140 : COMPARE_SCALAR_FIELD(remove);
2868 : :
2869 : 140 : return true;
2870 : : }
2871 : :
2872 : : static bool
2873 : 1164 : _equalAlterObjectSchemaStmt(const AlterObjectSchemaStmt *a, const AlterObjectSchemaStmt *b)
2874 : : {
2875 [ - + ]: 1164 : COMPARE_SCALAR_FIELD(objectType);
2876 [ - + ]: 1164 : COMPARE_NODE_FIELD(relation);
2877 [ - + ]: 1164 : COMPARE_NODE_FIELD(object);
2878 [ + - + - : 1164 : COMPARE_STRING_FIELD(newschema);
- + ]
2879 [ - + ]: 1164 : COMPARE_SCALAR_FIELD(missing_ok);
2880 : :
2881 : 1164 : return true;
2882 : : }
2883 : :
2884 : : static bool
2885 : 4076 : _equalAlterOwnerStmt(const AlterOwnerStmt *a, const AlterOwnerStmt *b)
2886 : : {
2887 [ - + ]: 4076 : COMPARE_SCALAR_FIELD(objectType);
2888 [ - + ]: 4076 : COMPARE_NODE_FIELD(relation);
2889 [ - + ]: 4076 : COMPARE_NODE_FIELD(object);
2890 [ - + ]: 4076 : COMPARE_NODE_FIELD(newowner);
2891 : :
2892 : 4076 : return true;
2893 : : }
2894 : :
2895 : : static bool
2896 : 1328 : _equalAlterOperatorStmt(const AlterOperatorStmt *a, const AlterOperatorStmt *b)
2897 : : {
2898 [ - + ]: 1328 : COMPARE_NODE_FIELD(opername);
2899 [ - + ]: 1328 : COMPARE_NODE_FIELD(options);
2900 : :
2901 : 1328 : return true;
2902 : : }
2903 : :
2904 : : static bool
2905 : 144 : _equalAlterTypeStmt(const AlterTypeStmt *a, const AlterTypeStmt *b)
2906 : : {
2907 [ - + ]: 144 : COMPARE_NODE_FIELD(typeName);
2908 [ - + ]: 144 : COMPARE_NODE_FIELD(options);
2909 : :
2910 : 144 : return true;
2911 : : }
2912 : :
2913 : : static bool
2914 : 3048 : _equalRuleStmt(const RuleStmt *a, const RuleStmt *b)
2915 : : {
2916 [ - + ]: 3048 : COMPARE_NODE_FIELD(relation);
2917 [ + - + - : 3048 : COMPARE_STRING_FIELD(rulename);
- + ]
2918 [ - + ]: 3048 : COMPARE_NODE_FIELD(whereClause);
2919 [ - + ]: 3048 : COMPARE_SCALAR_FIELD(event);
2920 [ - + ]: 3048 : COMPARE_SCALAR_FIELD(instead);
2921 [ - + ]: 3048 : COMPARE_NODE_FIELD(actions);
2922 [ - + ]: 3048 : COMPARE_SCALAR_FIELD(replace);
2923 : :
2924 : 3048 : return true;
2925 : : }
2926 : :
2927 : : static bool
2928 : 367 : _equalNotifyStmt(const NotifyStmt *a, const NotifyStmt *b)
2929 : : {
2930 [ + - + - : 367 : COMPARE_STRING_FIELD(conditionname);
- + ]
2931 [ + + + - : 367 : COMPARE_STRING_FIELD(payload);
- + ]
2932 : :
2933 : 367 : return true;
2934 : : }
2935 : :
2936 : : static bool
2937 : 208 : _equalListenStmt(const ListenStmt *a, const ListenStmt *b)
2938 : : {
2939 [ + - + - : 208 : COMPARE_STRING_FIELD(conditionname);
- + ]
2940 : :
2941 : 208 : return true;
2942 : : }
2943 : :
2944 : : static bool
2945 : 248 : _equalUnlistenStmt(const UnlistenStmt *a, const UnlistenStmt *b)
2946 : : {
2947 [ + + + - : 248 : COMPARE_STRING_FIELD(conditionname);
- + ]
2948 : :
2949 : 248 : return true;
2950 : : }
2951 : :
2952 : : static bool
2953 : 109144 : _equalTransactionStmt(const TransactionStmt *a, const TransactionStmt *b)
2954 : : {
2955 [ - + ]: 109144 : COMPARE_SCALAR_FIELD(kind);
2956 [ - + ]: 109144 : COMPARE_NODE_FIELD(options);
2957 [ + + + - : 109144 : COMPARE_STRING_FIELD(savepoint_name);
- + ]
2958 [ + + + - : 109144 : COMPARE_STRING_FIELD(gid);
- + ]
2959 [ - + ]: 109144 : COMPARE_SCALAR_FIELD(chain);
2960 : : COMPARE_LOCATION_FIELD(location);
2961 : :
2962 : 109144 : return true;
2963 : : }
2964 : :
2965 : : static bool
2966 : 5756 : _equalCompositeTypeStmt(const CompositeTypeStmt *a, const CompositeTypeStmt *b)
2967 : : {
2968 [ - + ]: 5756 : COMPARE_NODE_FIELD(typevar);
2969 [ - + ]: 5756 : COMPARE_NODE_FIELD(coldeflist);
2970 : :
2971 : 5756 : return true;
2972 : : }
2973 : :
2974 : : static bool
2975 : 664 : _equalCreateEnumStmt(const CreateEnumStmt *a, const CreateEnumStmt *b)
2976 : : {
2977 [ - + ]: 664 : COMPARE_NODE_FIELD(typeName);
2978 [ - + ]: 664 : COMPARE_NODE_FIELD(vals);
2979 : :
2980 : 664 : return true;
2981 : : }
2982 : :
2983 : : static bool
2984 : 632 : _equalCreateRangeStmt(const CreateRangeStmt *a, const CreateRangeStmt *b)
2985 : : {
2986 [ - + ]: 632 : COMPARE_NODE_FIELD(typeName);
2987 [ - + ]: 632 : COMPARE_NODE_FIELD(params);
2988 : :
2989 : 632 : return true;
2990 : : }
2991 : :
2992 : : static bool
2993 : 984 : _equalAlterEnumStmt(const AlterEnumStmt *a, const AlterEnumStmt *b)
2994 : : {
2995 [ - + ]: 984 : COMPARE_NODE_FIELD(typeName);
2996 [ + + + - : 984 : COMPARE_STRING_FIELD(oldVal);
- + ]
2997 [ + - + - : 984 : COMPARE_STRING_FIELD(newVal);
- + ]
2998 [ + + + - : 984 : COMPARE_STRING_FIELD(newValNeighbor);
- + ]
2999 [ - + ]: 984 : COMPARE_SCALAR_FIELD(newValIsAfter);
3000 [ - + ]: 984 : COMPARE_SCALAR_FIELD(skipIfNewValExists);
3001 : :
3002 : 984 : return true;
3003 : : }
3004 : :
3005 : : static bool
3006 : 44162 : _equalViewStmt(const ViewStmt *a, const ViewStmt *b)
3007 : : {
3008 [ - + ]: 44162 : COMPARE_NODE_FIELD(view);
3009 [ - + ]: 44162 : COMPARE_NODE_FIELD(aliases);
3010 [ - + ]: 44162 : COMPARE_NODE_FIELD(query);
3011 [ - + ]: 44162 : COMPARE_SCALAR_FIELD(replace);
3012 [ - + ]: 44162 : COMPARE_NODE_FIELD(options);
3013 [ - + ]: 44162 : COMPARE_SCALAR_FIELD(withCheckOption);
3014 : :
3015 : 44162 : return true;
3016 : : }
3017 : :
3018 : : static bool
3019 : 196 : _equalLoadStmt(const LoadStmt *a, const LoadStmt *b)
3020 : : {
3021 [ + - + - : 196 : COMPARE_STRING_FIELD(filename);
- + ]
3022 : :
3023 : 196 : return true;
3024 : : }
3025 : :
3026 : : static bool
3027 : 1796 : _equalCreatedbStmt(const CreatedbStmt *a, const CreatedbStmt *b)
3028 : : {
3029 [ + - + - : 1796 : COMPARE_STRING_FIELD(dbname);
- + ]
3030 [ - + ]: 1796 : COMPARE_NODE_FIELD(options);
3031 : :
3032 : 1796 : return true;
3033 : : }
3034 : :
3035 : : static bool
3036 : 212 : _equalAlterDatabaseStmt(const AlterDatabaseStmt *a, const AlterDatabaseStmt *b)
3037 : : {
3038 [ + - + - : 212 : COMPARE_STRING_FIELD(dbname);
- + ]
3039 [ - + ]: 212 : COMPARE_NODE_FIELD(options);
3040 : :
3041 : 212 : return true;
3042 : : }
3043 : :
3044 : : static bool
3045 : 16 : _equalAlterDatabaseRefreshCollStmt(const AlterDatabaseRefreshCollStmt *a, const AlterDatabaseRefreshCollStmt *b)
3046 : : {
3047 [ + - + - : 16 : COMPARE_STRING_FIELD(dbname);
- + ]
3048 : :
3049 : 16 : return true;
3050 : : }
3051 : :
3052 : : static bool
3053 : 2692 : _equalAlterDatabaseSetStmt(const AlterDatabaseSetStmt *a, const AlterDatabaseSetStmt *b)
3054 : : {
3055 [ + - + - : 2692 : COMPARE_STRING_FIELD(dbname);
- + ]
3056 [ - + ]: 2692 : COMPARE_NODE_FIELD(setstmt);
3057 : :
3058 : 2692 : return true;
3059 : : }
3060 : :
3061 : : static bool
3062 : 312 : _equalDropdbStmt(const DropdbStmt *a, const DropdbStmt *b)
3063 : : {
3064 [ + - + - : 312 : COMPARE_STRING_FIELD(dbname);
- + ]
3065 [ - + ]: 312 : COMPARE_SCALAR_FIELD(missing_ok);
3066 [ - + ]: 312 : COMPARE_NODE_FIELD(options);
3067 : :
3068 : 312 : return true;
3069 : : }
3070 : :
3071 : : static bool
3072 : 480 : _equalAlterSystemStmt(const AlterSystemStmt *a, const AlterSystemStmt *b)
3073 : : {
3074 [ - + ]: 480 : COMPARE_NODE_FIELD(setstmt);
3075 : :
3076 : 480 : return true;
3077 : : }
3078 : :
3079 : : static bool
3080 : 35828 : _equalVacuumStmt(const VacuumStmt *a, const VacuumStmt *b)
3081 : : {
3082 [ - + ]: 35828 : COMPARE_NODE_FIELD(options);
3083 [ - + ]: 35828 : COMPARE_NODE_FIELD(rels);
3084 [ - + ]: 35828 : COMPARE_SCALAR_FIELD(is_vacuumcmd);
3085 : :
3086 : 35828 : return true;
3087 : : }
3088 : :
3089 : : static bool
3090 : 36340 : _equalVacuumRelation(const VacuumRelation *a, const VacuumRelation *b)
3091 : : {
3092 [ - + ]: 36340 : COMPARE_NODE_FIELD(relation);
3093 [ - + ]: 36340 : COMPARE_SCALAR_FIELD(oid);
3094 [ - + ]: 36340 : COMPARE_NODE_FIELD(va_cols);
3095 : :
3096 : 36340 : return true;
3097 : : }
3098 : :
3099 : : static bool
3100 : 928 : _equalRepackStmt(const RepackStmt *a, const RepackStmt *b)
3101 : : {
3102 [ - + ]: 928 : COMPARE_SCALAR_FIELD(command);
3103 [ - + ]: 928 : COMPARE_NODE_FIELD(relation);
3104 [ + + + - : 928 : COMPARE_STRING_FIELD(indexname);
- + ]
3105 [ - + ]: 928 : COMPARE_SCALAR_FIELD(usingindex);
3106 [ - + ]: 928 : COMPARE_NODE_FIELD(params);
3107 : :
3108 : 928 : return true;
3109 : : }
3110 : :
3111 : : static bool
3112 : 55952 : _equalExplainStmt(const ExplainStmt *a, const ExplainStmt *b)
3113 : : {
3114 [ - + ]: 55952 : COMPARE_NODE_FIELD(query);
3115 [ - + ]: 55952 : COMPARE_NODE_FIELD(options);
3116 : :
3117 : 55952 : return true;
3118 : : }
3119 : :
3120 : : static bool
3121 : 5044 : _equalCreateTableAsStmt(const CreateTableAsStmt *a, const CreateTableAsStmt *b)
3122 : : {
3123 [ - + ]: 5044 : COMPARE_NODE_FIELD(query);
3124 [ - + ]: 5044 : COMPARE_NODE_FIELD(into);
3125 [ - + ]: 5044 : COMPARE_SCALAR_FIELD(objtype);
3126 [ - + ]: 5044 : COMPARE_SCALAR_FIELD(is_select_into);
3127 [ - + ]: 5044 : COMPARE_SCALAR_FIELD(if_not_exists);
3128 : :
3129 : 5044 : return true;
3130 : : }
3131 : :
3132 : : static bool
3133 : 696 : _equalRefreshMatViewStmt(const RefreshMatViewStmt *a, const RefreshMatViewStmt *b)
3134 : : {
3135 [ - + ]: 696 : COMPARE_SCALAR_FIELD(concurrent);
3136 [ - + ]: 696 : COMPARE_SCALAR_FIELD(skipData);
3137 [ - + ]: 696 : COMPARE_NODE_FIELD(relation);
3138 : :
3139 : 696 : return true;
3140 : : }
3141 : :
3142 : : static bool
3143 : 582 : _equalCheckPointStmt(const CheckPointStmt *a, const CheckPointStmt *b)
3144 : : {
3145 [ - + ]: 582 : COMPARE_NODE_FIELD(options);
3146 : :
3147 : 582 : return true;
3148 : : }
3149 : :
3150 : : static bool
3151 : 96 : _equalDiscardStmt(const DiscardStmt *a, const DiscardStmt *b)
3152 : : {
3153 [ - + ]: 96 : COMPARE_SCALAR_FIELD(target);
3154 : :
3155 : 96 : return true;
3156 : : }
3157 : :
3158 : : static bool
3159 : 2388 : _equalLockStmt(const LockStmt *a, const LockStmt *b)
3160 : : {
3161 [ - + ]: 2388 : COMPARE_NODE_FIELD(relations);
3162 [ - + ]: 2388 : COMPARE_SCALAR_FIELD(mode);
3163 [ - + ]: 2388 : COMPARE_SCALAR_FIELD(nowait);
3164 : :
3165 : 2388 : return true;
3166 : : }
3167 : :
3168 : : static bool
3169 : 282 : _equalConstraintsSetStmt(const ConstraintsSetStmt *a, const ConstraintsSetStmt *b)
3170 : : {
3171 [ - + ]: 282 : COMPARE_NODE_FIELD(constraints);
3172 [ - + ]: 282 : COMPARE_SCALAR_FIELD(deferred);
3173 : :
3174 : 282 : return true;
3175 : : }
3176 : :
3177 : : static bool
3178 : 2836 : _equalReindexStmt(const ReindexStmt *a, const ReindexStmt *b)
3179 : : {
3180 [ - + ]: 2836 : COMPARE_SCALAR_FIELD(kind);
3181 [ - + ]: 2836 : COMPARE_NODE_FIELD(relation);
3182 [ + + + - : 2836 : COMPARE_STRING_FIELD(name);
- + ]
3183 [ - + ]: 2836 : COMPARE_NODE_FIELD(params);
3184 : :
3185 : 2836 : return true;
3186 : : }
3187 : :
3188 : : static bool
3189 : 168 : _equalCreateConversionStmt(const CreateConversionStmt *a, const CreateConversionStmt *b)
3190 : : {
3191 [ - + ]: 168 : COMPARE_NODE_FIELD(conversion_name);
3192 [ + - + - : 168 : COMPARE_STRING_FIELD(for_encoding_name);
- + ]
3193 [ + - + - : 168 : COMPARE_STRING_FIELD(to_encoding_name);
- + ]
3194 [ - + ]: 168 : COMPARE_NODE_FIELD(func_name);
3195 [ - + ]: 168 : COMPARE_SCALAR_FIELD(def);
3196 : :
3197 : 168 : return true;
3198 : : }
3199 : :
3200 : : static bool
3201 : 704 : _equalCreateCastStmt(const CreateCastStmt *a, const CreateCastStmt *b)
3202 : : {
3203 [ - + ]: 704 : COMPARE_NODE_FIELD(sourcetype);
3204 [ - + ]: 704 : COMPARE_NODE_FIELD(targettype);
3205 [ - + ]: 704 : COMPARE_NODE_FIELD(func);
3206 [ - + ]: 704 : COMPARE_SCALAR_FIELD(context);
3207 [ - + ]: 704 : COMPARE_SCALAR_FIELD(inout);
3208 : :
3209 : 704 : return true;
3210 : : }
3211 : :
3212 : : static bool
3213 : 872 : _equalCreatePropGraphStmt(const CreatePropGraphStmt *a, const CreatePropGraphStmt *b)
3214 : : {
3215 [ - + ]: 872 : COMPARE_NODE_FIELD(pgname);
3216 [ - + ]: 872 : COMPARE_NODE_FIELD(vertex_tables);
3217 [ - + ]: 872 : COMPARE_NODE_FIELD(edge_tables);
3218 : :
3219 : 872 : return true;
3220 : : }
3221 : :
3222 : : static bool
3223 : 1676 : _equalPropGraphVertex(const PropGraphVertex *a, const PropGraphVertex *b)
3224 : : {
3225 [ - + ]: 1676 : COMPARE_NODE_FIELD(vtable);
3226 [ - + ]: 1676 : COMPARE_NODE_FIELD(vkey);
3227 [ - + ]: 1676 : COMPARE_NODE_FIELD(labels);
3228 : : COMPARE_LOCATION_FIELD(location);
3229 : :
3230 : 1676 : return true;
3231 : : }
3232 : :
3233 : : static bool
3234 : 868 : _equalPropGraphEdge(const PropGraphEdge *a, const PropGraphEdge *b)
3235 : : {
3236 [ - + ]: 868 : COMPARE_NODE_FIELD(etable);
3237 [ - + ]: 868 : COMPARE_NODE_FIELD(ekey);
3238 [ - + ]: 868 : COMPARE_NODE_FIELD(esrckey);
3239 [ + - + - : 868 : COMPARE_STRING_FIELD(esrcvertex);
- + ]
3240 [ - + ]: 868 : COMPARE_NODE_FIELD(esrcvertexcols);
3241 [ - + ]: 868 : COMPARE_NODE_FIELD(edestkey);
3242 [ + - + - : 868 : COMPARE_STRING_FIELD(edestvertex);
- + ]
3243 [ - + ]: 868 : COMPARE_NODE_FIELD(edestvertexcols);
3244 [ - + ]: 868 : COMPARE_NODE_FIELD(labels);
3245 : : COMPARE_LOCATION_FIELD(location);
3246 : :
3247 : 868 : return true;
3248 : : }
3249 : :
3250 : : static bool
3251 : 3164 : _equalPropGraphLabelAndProperties(const PropGraphLabelAndProperties *a, const PropGraphLabelAndProperties *b)
3252 : : {
3253 [ + + + - : 3164 : COMPARE_STRING_FIELD(label);
- + ]
3254 [ - + ]: 3164 : COMPARE_NODE_FIELD(properties);
3255 : : COMPARE_LOCATION_FIELD(location);
3256 : :
3257 : 3164 : return true;
3258 : : }
3259 : :
3260 : : static bool
3261 : 3212 : _equalPropGraphProperties(const PropGraphProperties *a, const PropGraphProperties *b)
3262 : : {
3263 [ - + ]: 3212 : COMPARE_NODE_FIELD(properties);
3264 [ - + ]: 3212 : COMPARE_SCALAR_FIELD(all);
3265 : : COMPARE_LOCATION_FIELD(location);
3266 : :
3267 : 3212 : return true;
3268 : : }
3269 : :
3270 : : static bool
3271 : 672 : _equalAlterPropGraphStmt(const AlterPropGraphStmt *a, const AlterPropGraphStmt *b)
3272 : : {
3273 [ - + ]: 672 : COMPARE_NODE_FIELD(pgname);
3274 [ - + ]: 672 : COMPARE_SCALAR_FIELD(missing_ok);
3275 [ - + ]: 672 : COMPARE_NODE_FIELD(add_vertex_tables);
3276 [ - + ]: 672 : COMPARE_NODE_FIELD(add_edge_tables);
3277 [ - + ]: 672 : COMPARE_NODE_FIELD(drop_vertex_tables);
3278 [ - + ]: 672 : COMPARE_NODE_FIELD(drop_edge_tables);
3279 [ - + ]: 672 : COMPARE_SCALAR_FIELD(drop_behavior);
3280 [ - + ]: 672 : COMPARE_SCALAR_FIELD(element_kind);
3281 [ + + + - : 672 : COMPARE_STRING_FIELD(element_alias);
- + ]
3282 [ - + ]: 672 : COMPARE_NODE_FIELD(add_labels);
3283 [ + + + - : 672 : COMPARE_STRING_FIELD(drop_label);
- + ]
3284 [ + + + - : 672 : COMPARE_STRING_FIELD(alter_label);
- + ]
3285 [ - + ]: 672 : COMPARE_NODE_FIELD(add_properties);
3286 [ - + ]: 672 : COMPARE_NODE_FIELD(drop_properties);
3287 : :
3288 : 672 : return true;
3289 : : }
3290 : :
3291 : : static bool
3292 : 104 : _equalCreateTransformStmt(const CreateTransformStmt *a, const CreateTransformStmt *b)
3293 : : {
3294 [ - + ]: 104 : COMPARE_SCALAR_FIELD(replace);
3295 [ - + ]: 104 : COMPARE_NODE_FIELD(type_name);
3296 [ + - + - : 104 : COMPARE_STRING_FIELD(lang);
- + ]
3297 [ - + ]: 104 : COMPARE_NODE_FIELD(fromsql);
3298 [ - + ]: 104 : COMPARE_NODE_FIELD(tosql);
3299 : :
3300 : 104 : return true;
3301 : : }
3302 : :
3303 : : static bool
3304 : 4560 : _equalPrepareStmt(const PrepareStmt *a, const PrepareStmt *b)
3305 : : {
3306 [ + - + - : 4560 : COMPARE_STRING_FIELD(name);
- + ]
3307 [ - + ]: 4560 : COMPARE_NODE_FIELD(argtypes);
3308 [ - + ]: 4560 : COMPARE_NODE_FIELD(query);
3309 : :
3310 : 4560 : return true;
3311 : : }
3312 : :
3313 : : static bool
3314 : 36108 : _equalExecuteStmt(const ExecuteStmt *a, const ExecuteStmt *b)
3315 : : {
3316 [ + - + - : 36108 : COMPARE_STRING_FIELD(name);
- + ]
3317 [ - + ]: 36108 : COMPARE_NODE_FIELD(params);
3318 : :
3319 : 36108 : return true;
3320 : : }
3321 : :
3322 : : static bool
3323 : 8392 : _equalDeallocateStmt(const DeallocateStmt *a, const DeallocateStmt *b)
3324 : : {
3325 [ + + + - : 8392 : COMPARE_STRING_FIELD(name);
- + ]
3326 [ - + ]: 8392 : COMPARE_SCALAR_FIELD(isall);
3327 : : COMPARE_LOCATION_FIELD(location);
3328 : :
3329 : 8392 : return true;
3330 : : }
3331 : :
3332 : : static bool
3333 : 384 : _equalDropOwnedStmt(const DropOwnedStmt *a, const DropOwnedStmt *b)
3334 : : {
3335 [ - + ]: 384 : COMPARE_NODE_FIELD(roles);
3336 [ - + ]: 384 : COMPARE_SCALAR_FIELD(behavior);
3337 : :
3338 : 384 : return true;
3339 : : }
3340 : :
3341 : : static bool
3342 : 144 : _equalReassignOwnedStmt(const ReassignOwnedStmt *a, const ReassignOwnedStmt *b)
3343 : : {
3344 [ - + ]: 144 : COMPARE_NODE_FIELD(roles);
3345 [ - + ]: 144 : COMPARE_NODE_FIELD(newrole);
3346 : :
3347 : 144 : return true;
3348 : : }
3349 : :
3350 : : static bool
3351 : 92 : _equalAlterTSDictionaryStmt(const AlterTSDictionaryStmt *a, const AlterTSDictionaryStmt *b)
3352 : : {
3353 [ - + ]: 92 : COMPARE_NODE_FIELD(dictname);
3354 [ - + ]: 92 : COMPARE_NODE_FIELD(options);
3355 : :
3356 : 92 : return true;
3357 : : }
3358 : :
3359 : : static bool
3360 : 21000 : _equalAlterTSConfigurationStmt(const AlterTSConfigurationStmt *a, const AlterTSConfigurationStmt *b)
3361 : : {
3362 [ - + ]: 21000 : COMPARE_SCALAR_FIELD(kind);
3363 [ - + ]: 21000 : COMPARE_NODE_FIELD(cfgname);
3364 [ - + ]: 21000 : COMPARE_NODE_FIELD(tokentype);
3365 [ - + ]: 21000 : COMPARE_NODE_FIELD(dicts);
3366 [ - + ]: 21000 : COMPARE_SCALAR_FIELD(override);
3367 [ - + ]: 21000 : COMPARE_SCALAR_FIELD(replace);
3368 [ - + ]: 21000 : COMPARE_SCALAR_FIELD(missing_ok);
3369 : :
3370 : 21000 : return true;
3371 : : }
3372 : :
3373 : : static bool
3374 : 4100 : _equalPublicationTable(const PublicationTable *a, const PublicationTable *b)
3375 : : {
3376 [ - + ]: 4100 : COMPARE_NODE_FIELD(relation);
3377 [ - + ]: 4100 : COMPARE_NODE_FIELD(whereClause);
3378 [ - + ]: 4100 : COMPARE_NODE_FIELD(columns);
3379 [ - + ]: 4100 : COMPARE_SCALAR_FIELD(except);
3380 : :
3381 : 4100 : return true;
3382 : : }
3383 : :
3384 : : static bool
3385 : 5160 : _equalPublicationObjSpec(const PublicationObjSpec *a, const PublicationObjSpec *b)
3386 : : {
3387 [ - + ]: 5160 : COMPARE_SCALAR_FIELD(pubobjtype);
3388 [ + + + - : 5160 : COMPARE_STRING_FIELD(name);
- + ]
3389 [ - + ]: 5160 : COMPARE_NODE_FIELD(pubtable);
3390 : : COMPARE_LOCATION_FIELD(location);
3391 : :
3392 : 5160 : return true;
3393 : : }
3394 : :
3395 : : static bool
3396 : 0 : _equalPublicationAllObjSpec(const PublicationAllObjSpec *a, const PublicationAllObjSpec *b)
3397 : : {
3398 [ # # ]: 0 : COMPARE_SCALAR_FIELD(pubobjtype);
3399 [ # # ]: 0 : COMPARE_NODE_FIELD(except_tables);
3400 : : COMPARE_LOCATION_FIELD(location);
3401 : :
3402 : 0 : return true;
3403 : : }
3404 : :
3405 : : static bool
3406 : 2544 : _equalCreatePublicationStmt(const CreatePublicationStmt *a, const CreatePublicationStmt *b)
3407 : : {
3408 [ + - + - : 2544 : COMPARE_STRING_FIELD(pubname);
- + ]
3409 [ - + ]: 2544 : COMPARE_NODE_FIELD(options);
3410 [ - + ]: 2544 : COMPARE_NODE_FIELD(pubobjects);
3411 [ - + ]: 2544 : COMPARE_SCALAR_FIELD(for_all_tables);
3412 [ - + ]: 2544 : COMPARE_SCALAR_FIELD(for_all_sequences);
3413 : :
3414 : 2544 : return true;
3415 : : }
3416 : :
3417 : : static bool
3418 : 3124 : _equalAlterPublicationStmt(const AlterPublicationStmt *a, const AlterPublicationStmt *b)
3419 : : {
3420 [ + - + - : 3124 : COMPARE_STRING_FIELD(pubname);
- + ]
3421 [ - + ]: 3124 : COMPARE_NODE_FIELD(options);
3422 [ - + ]: 3124 : COMPARE_NODE_FIELD(pubobjects);
3423 [ - + ]: 3124 : COMPARE_SCALAR_FIELD(action);
3424 [ - + ]: 3124 : COMPARE_SCALAR_FIELD(for_all_tables);
3425 [ - + ]: 3124 : COMPARE_SCALAR_FIELD(for_all_sequences);
3426 : :
3427 : 3124 : return true;
3428 : : }
3429 : :
3430 : : static bool
3431 : 1340 : _equalCreateSubscriptionStmt(const CreateSubscriptionStmt *a, const CreateSubscriptionStmt *b)
3432 : : {
3433 [ + - + - : 1340 : COMPARE_STRING_FIELD(subname);
- + ]
3434 [ + + + - : 1340 : COMPARE_STRING_FIELD(servername);
- + ]
3435 [ + + + - : 1340 : COMPARE_STRING_FIELD(conninfo);
- + ]
3436 [ - + ]: 1340 : COMPARE_NODE_FIELD(publication);
3437 [ - + ]: 1340 : COMPARE_NODE_FIELD(options);
3438 : :
3439 : 1340 : return true;
3440 : : }
3441 : :
3442 : : static bool
3443 : 1794 : _equalAlterSubscriptionStmt(const AlterSubscriptionStmt *a, const AlterSubscriptionStmt *b)
3444 : : {
3445 [ - + ]: 1794 : COMPARE_SCALAR_FIELD(kind);
3446 [ + - + - : 1794 : COMPARE_STRING_FIELD(subname);
- + ]
3447 [ + + + - : 1794 : COMPARE_STRING_FIELD(servername);
- + ]
3448 [ + + + - : 1794 : COMPARE_STRING_FIELD(conninfo);
- + ]
3449 [ - + ]: 1794 : COMPARE_NODE_FIELD(publication);
3450 [ - + ]: 1794 : COMPARE_NODE_FIELD(options);
3451 : :
3452 : 1794 : return true;
3453 : : }
3454 : :
3455 : : static bool
3456 : 720 : _equalDropSubscriptionStmt(const DropSubscriptionStmt *a, const DropSubscriptionStmt *b)
3457 : : {
3458 [ + - + - : 720 : COMPARE_STRING_FIELD(subname);
- + ]
3459 [ - + ]: 720 : COMPARE_SCALAR_FIELD(missing_ok);
3460 [ - + ]: 720 : COMPARE_SCALAR_FIELD(behavior);
3461 : :
3462 : 720 : return true;
3463 : : }
3464 : :
3465 : : static bool
3466 : 1054 : _equalWaitStmt(const WaitStmt *a, const WaitStmt *b)
3467 : : {
3468 [ + - + - : 1054 : COMPARE_STRING_FIELD(lsn_literal);
- + ]
3469 [ - + ]: 1054 : COMPARE_NODE_FIELD(options);
3470 : :
3471 : 1054 : return true;
3472 : : }
3473 : :
3474 : : static bool
3475 : 0 : _equalPathKey(const PathKey *a, const PathKey *b)
3476 : : {
3477 [ # # ]: 0 : COMPARE_SCALAR_FIELD(pk_eclass);
3478 [ # # ]: 0 : COMPARE_SCALAR_FIELD(pk_opfamily);
3479 [ # # ]: 0 : COMPARE_SCALAR_FIELD(pk_cmptype);
3480 [ # # ]: 0 : COMPARE_SCALAR_FIELD(pk_nulls_first);
3481 : :
3482 : 0 : return true;
3483 : : }
3484 : :
3485 : : static bool
3486 : 0 : _equalGroupByOrdering(const GroupByOrdering *a, const GroupByOrdering *b)
3487 : : {
3488 [ # # ]: 0 : COMPARE_NODE_FIELD(pathkeys);
3489 [ # # ]: 0 : COMPARE_NODE_FIELD(clauses);
3490 : :
3491 : 0 : return true;
3492 : : }
3493 : :
3494 : : static bool
3495 : 684 : _equalRestrictInfo(const RestrictInfo *a, const RestrictInfo *b)
3496 : : {
3497 [ + + ]: 684 : COMPARE_NODE_FIELD(clause);
3498 [ - + ]: 122 : COMPARE_SCALAR_FIELD(is_pushed_down);
3499 [ - + ]: 122 : COMPARE_SCALAR_FIELD(has_clone);
3500 [ - + ]: 122 : COMPARE_SCALAR_FIELD(is_clone);
3501 [ - + ]: 122 : COMPARE_SCALAR_FIELD(security_level);
3502 [ + + ]: 122 : COMPARE_BITMAPSET_FIELD(required_relids);
3503 [ - + ]: 112 : COMPARE_BITMAPSET_FIELD(incompatible_relids);
3504 [ - + ]: 112 : COMPARE_BITMAPSET_FIELD(outer_relids);
3505 [ - + ]: 112 : COMPARE_SCALAR_FIELD(rinfo_serial);
3506 : :
3507 : 112 : return true;
3508 : : }
3509 : :
3510 : : static bool
3511 : 6229 : _equalPlaceHolderVar(const PlaceHolderVar *a, const PlaceHolderVar *b)
3512 : : {
3513 [ + + ]: 6229 : COMPARE_BITMAPSET_FIELD(phnullingrels);
3514 [ + + ]: 5496 : COMPARE_SCALAR_FIELD(phid);
3515 [ - + ]: 4067 : COMPARE_SCALAR_FIELD(phlevelsup);
3516 : :
3517 : 4067 : return true;
3518 : : }
3519 : :
3520 : : static bool
3521 : 0 : _equalSpecialJoinInfo(const SpecialJoinInfo *a, const SpecialJoinInfo *b)
3522 : : {
3523 [ # # ]: 0 : COMPARE_BITMAPSET_FIELD(min_lefthand);
3524 [ # # ]: 0 : COMPARE_BITMAPSET_FIELD(min_righthand);
3525 [ # # ]: 0 : COMPARE_BITMAPSET_FIELD(syn_lefthand);
3526 [ # # ]: 0 : COMPARE_BITMAPSET_FIELD(syn_righthand);
3527 [ # # ]: 0 : COMPARE_SCALAR_FIELD(jointype);
3528 [ # # ]: 0 : COMPARE_SCALAR_FIELD(ojrelid);
3529 [ # # ]: 0 : COMPARE_BITMAPSET_FIELD(commute_above_l);
3530 [ # # ]: 0 : COMPARE_BITMAPSET_FIELD(commute_above_r);
3531 [ # # ]: 0 : COMPARE_BITMAPSET_FIELD(commute_below_l);
3532 [ # # ]: 0 : COMPARE_BITMAPSET_FIELD(commute_below_r);
3533 [ # # ]: 0 : COMPARE_SCALAR_FIELD(lhs_strict);
3534 [ # # ]: 0 : COMPARE_SCALAR_FIELD(semi_can_btree);
3535 [ # # ]: 0 : COMPARE_SCALAR_FIELD(semi_can_hash);
3536 [ # # ]: 0 : COMPARE_NODE_FIELD(semi_operators);
3537 [ # # ]: 0 : COMPARE_NODE_FIELD(semi_rhs_exprs);
3538 : :
3539 : 0 : return true;
3540 : : }
3541 : :
3542 : : static bool
3543 : 0 : _equalAppendRelInfo(const AppendRelInfo *a, const AppendRelInfo *b)
3544 : : {
3545 [ # # ]: 0 : COMPARE_SCALAR_FIELD(parent_relid);
3546 [ # # ]: 0 : COMPARE_SCALAR_FIELD(child_relid);
3547 [ # # ]: 0 : COMPARE_SCALAR_FIELD(parent_reltype);
3548 [ # # ]: 0 : COMPARE_SCALAR_FIELD(child_reltype);
3549 [ # # ]: 0 : COMPARE_NODE_FIELD(translated_vars);
3550 [ # # ]: 0 : COMPARE_SCALAR_FIELD(num_child_cols);
3551 [ # # ]: 0 : COMPARE_POINTER_FIELD(parent_colnos, a->num_child_cols * sizeof(AttrNumber));
3552 [ # # ]: 0 : COMPARE_SCALAR_FIELD(parent_reloid);
3553 : :
3554 : 0 : return true;
3555 : : }
3556 : :
3557 : : static bool
3558 : 0 : _equalPlaceHolderInfo(const PlaceHolderInfo *a, const PlaceHolderInfo *b)
3559 : : {
3560 [ # # ]: 0 : COMPARE_SCALAR_FIELD(phid);
3561 [ # # ]: 0 : COMPARE_NODE_FIELD(ph_var);
3562 [ # # ]: 0 : COMPARE_BITMAPSET_FIELD(ph_eval_at);
3563 [ # # ]: 0 : COMPARE_BITMAPSET_FIELD(ph_lateral);
3564 [ # # ]: 0 : COMPARE_BITMAPSET_FIELD(ph_needed);
3565 [ # # ]: 0 : COMPARE_SCALAR_FIELD(ph_width);
3566 : :
3567 : 0 : return true;
3568 : : }
3569 : :
3570 : : static bool
3571 : 160 : _equalAggClauseInfo(const AggClauseInfo *a, const AggClauseInfo *b)
3572 : : {
3573 [ + + ]: 160 : COMPARE_NODE_FIELD(aggref);
3574 [ - + ]: 5 : COMPARE_BITMAPSET_FIELD(agg_eval_at);
3575 : :
3576 : 5 : return true;
3577 : : }
3578 : :
3579 : : static bool
3580 : 0 : _equalGroupingExprInfo(const GroupingExprInfo *a, const GroupingExprInfo *b)
3581 : : {
3582 [ # # ]: 0 : COMPARE_NODE_FIELD(expr);
3583 [ # # ]: 0 : COMPARE_SCALAR_FIELD(sortgroupref);
3584 [ # # ]: 0 : COMPARE_SCALAR_FIELD(ec);
3585 : :
3586 : 0 : return true;
3587 : : }
3588 : :
3589 : : static bool
3590 : 0 : _equalSubPlanRTInfo(const SubPlanRTInfo *a, const SubPlanRTInfo *b)
3591 : : {
3592 [ # # # # : 0 : COMPARE_STRING_FIELD(plan_name);
# # ]
3593 [ # # ]: 0 : COMPARE_SCALAR_FIELD(rtoffset);
3594 [ # # ]: 0 : COMPARE_SCALAR_FIELD(dummy);
3595 : :
3596 : 0 : return true;
3597 : : }
3598 : :
3599 : : static bool
3600 : 0 : _equalElidedNode(const ElidedNode *a, const ElidedNode *b)
3601 : : {
3602 [ # # ]: 0 : COMPARE_SCALAR_FIELD(plan_node_id);
3603 [ # # ]: 0 : COMPARE_SCALAR_FIELD(elided_type);
3604 [ # # ]: 0 : COMPARE_BITMAPSET_FIELD(relids);
3605 : :
3606 : 0 : return true;
3607 : : }
3608 : :
3609 : : static bool
3610 : 642416 : _equalInteger(const Integer *a, const Integer *b)
3611 : : {
3612 [ - + ]: 642416 : COMPARE_SCALAR_FIELD(ival);
3613 : :
3614 : 642416 : return true;
3615 : : }
3616 : :
3617 : : static bool
3618 : 16770 : _equalFloat(const Float *a, const Float *b)
3619 : : {
3620 [ + - + - : 16770 : COMPARE_STRING_FIELD(fval);
- + ]
3621 : :
3622 : 16770 : return true;
3623 : : }
3624 : :
3625 : : static bool
3626 : 113516 : _equalBoolean(const Boolean *a, const Boolean *b)
3627 : : {
3628 [ - + ]: 113516 : COMPARE_SCALAR_FIELD(boolval);
3629 : :
3630 : 113516 : return true;
3631 : : }
3632 : :
3633 : : static bool
3634 : 21987861 : _equalString(const String *a, const String *b)
3635 : : {
3636 [ + - + - : 21987861 : COMPARE_STRING_FIELD(sval);
+ + ]
3637 : :
3638 : 21494805 : return true;
3639 : : }
3640 : :
3641 : : static bool
3642 : 5470 : _equalBitString(const BitString *a, const BitString *b)
3643 : : {
3644 [ + - + - : 5470 : COMPARE_STRING_FIELD(bsval);
- + ]
3645 : :
3646 : 5470 : return true;
3647 : : }
|
