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