From 8a9c1c8cee83179a738ae428fc5e1dfb25fabf09 Mon Sep 17 00:00:00 2001 From: "dgrowley@gmail.com" Date: Thu, 28 May 2020 23:36:22 +1200 Subject: [PATCH 1/2] Refactor equal funcs to use macros specific to the data type There is no functionality change here. This is just making way for a future patch which does a conversion to add a node comparison function. As of now all the new macros just make use of the existing COMPARE_SCALAR_FIELD macro. In the future these will return -1/0/+1 --- src/backend/nodes/equalfuncs.c | 902 +++++++++++++++++---------------- 1 file changed, 456 insertions(+), 446 deletions(-) diff --git a/src/backend/nodes/equalfuncs.c b/src/backend/nodes/equalfuncs.c index 627b026b19..bd77ef4349 100644 --- a/src/backend/nodes/equalfuncs.c +++ b/src/backend/nodes/equalfuncs.c @@ -89,6 +89,16 @@ #define COMPARE_COERCIONFORM_FIELD(fldname) \ ((void) 0) +#define COMPARE_BOOL_FIELD(fldname) COMPARE_SCALAR_FIELD(fldname) +#define COMPARE_CHAR_FIELD(fldname) COMPARE_SCALAR_FIELD(fldname) +#define COMPARE_INT_FIELD(fldname) COMPARE_SCALAR_FIELD(fldname) +#define COMPARE_UINT_FIELD(fldname) COMPARE_SCALAR_FIELD(fldname) +#define COMPARE_LONG_FIELD(fldname) COMPARE_SCALAR_FIELD(fldname) +#define COMPARE_DOUBLE_FIELD(fldname) COMPARE_SCALAR_FIELD(fldname) +#define COMPARE_OID_FIELD(fldname) COMPARE_SCALAR_FIELD(fldname) +#define COMPARE_POINTER_VALUE_FIELD(fldname) COMPARE_SCALAR_FIELD(fldname) +#define COMPARE_ENUM_FIELD(fldname, enumtype) COMPARE_SCALAR_FIELD(fldname) + /* * Stuff from primnodes.h @@ -109,8 +119,8 @@ _equalRangeVar(const RangeVar *a, const RangeVar *b) COMPARE_STRING_FIELD(catalogname); COMPARE_STRING_FIELD(schemaname); COMPARE_STRING_FIELD(relname); - COMPARE_SCALAR_FIELD(inh); - COMPARE_SCALAR_FIELD(relpersistence); + COMPARE_BOOL_FIELD(inh); + COMPARE_CHAR_FIELD(relpersistence); COMPARE_NODE_FIELD(alias); COMPARE_LOCATION_FIELD(location); @@ -131,7 +141,7 @@ _equalTableFunc(const TableFunc *a, const TableFunc *b) COMPARE_NODE_FIELD(colexprs); COMPARE_NODE_FIELD(coldefexprs); COMPARE_BITMAPSET_FIELD(notnulls); - COMPARE_SCALAR_FIELD(ordinalitycol); + COMPARE_INT_FIELD(ordinalitycol); COMPARE_LOCATION_FIELD(location); return true; @@ -144,10 +154,10 @@ _equalIntoClause(const IntoClause *a, const IntoClause *b) COMPARE_NODE_FIELD(colNames); COMPARE_STRING_FIELD(accessMethod); COMPARE_NODE_FIELD(options); - COMPARE_SCALAR_FIELD(onCommit); + COMPARE_ENUM_FIELD(onCommit, OnCommitAction); COMPARE_STRING_FIELD(tableSpaceName); COMPARE_NODE_FIELD(viewQuery); - COMPARE_SCALAR_FIELD(skipData); + COMPARE_BOOL_FIELD(skipData); return true; } @@ -162,12 +172,12 @@ _equalIntoClause(const IntoClause *a, const IntoClause *b) static bool _equalVar(const Var *a, const Var *b) { - COMPARE_SCALAR_FIELD(varno); - COMPARE_SCALAR_FIELD(varattno); - COMPARE_SCALAR_FIELD(vartype); - COMPARE_SCALAR_FIELD(vartypmod); - COMPARE_SCALAR_FIELD(varcollid); - COMPARE_SCALAR_FIELD(varlevelsup); + COMPARE_UINT_FIELD(varno); + COMPARE_INT_FIELD(varattno); + COMPARE_OID_FIELD(vartype); + COMPARE_INT_FIELD(vartypmod); + COMPARE_OID_FIELD(varcollid); + COMPARE_UINT_FIELD(varlevelsup); /* * varnosyn/varattnosyn are intentionally ignored here, because Vars with @@ -182,12 +192,12 @@ _equalVar(const Var *a, const Var *b) static bool _equalConst(const Const *a, const Const *b) { - COMPARE_SCALAR_FIELD(consttype); - COMPARE_SCALAR_FIELD(consttypmod); - COMPARE_SCALAR_FIELD(constcollid); - COMPARE_SCALAR_FIELD(constlen); - COMPARE_SCALAR_FIELD(constisnull); - COMPARE_SCALAR_FIELD(constbyval); + COMPARE_OID_FIELD(consttype); + COMPARE_INT_FIELD(consttypmod); + COMPARE_OID_FIELD(constcollid); + COMPARE_INT_FIELD(constlen); + COMPARE_BOOL_FIELD(constisnull); + COMPARE_BOOL_FIELD(constbyval); COMPARE_LOCATION_FIELD(location); /* @@ -203,11 +213,11 @@ _equalConst(const Const *a, const Const *b) static bool _equalParam(const Param *a, const Param *b) { - COMPARE_SCALAR_FIELD(paramkind); - COMPARE_SCALAR_FIELD(paramid); - COMPARE_SCALAR_FIELD(paramtype); - COMPARE_SCALAR_FIELD(paramtypmod); - COMPARE_SCALAR_FIELD(paramcollid); + COMPARE_ENUM_FIELD(paramkind, ParamKind); + COMPARE_INT_FIELD(paramid); + COMPARE_OID_FIELD(paramtype); + COMPARE_INT_FIELD(paramtypmod); + COMPARE_OID_FIELD(paramcollid); COMPARE_LOCATION_FIELD(location); return true; @@ -216,10 +226,10 @@ _equalParam(const Param *a, const Param *b) static bool _equalAggref(const Aggref *a, const Aggref *b) { - COMPARE_SCALAR_FIELD(aggfnoid); - COMPARE_SCALAR_FIELD(aggtype); - COMPARE_SCALAR_FIELD(aggcollid); - COMPARE_SCALAR_FIELD(inputcollid); + COMPARE_OID_FIELD(aggfnoid); + COMPARE_OID_FIELD(aggtype); + COMPARE_OID_FIELD(aggcollid); + COMPARE_OID_FIELD(inputcollid); /* ignore aggtranstype since it might not be set yet */ COMPARE_NODE_FIELD(aggargtypes); COMPARE_NODE_FIELD(aggdirectargs); @@ -227,11 +237,11 @@ _equalAggref(const Aggref *a, const Aggref *b) COMPARE_NODE_FIELD(aggorder); COMPARE_NODE_FIELD(aggdistinct); COMPARE_NODE_FIELD(aggfilter); - COMPARE_SCALAR_FIELD(aggstar); - COMPARE_SCALAR_FIELD(aggvariadic); - COMPARE_SCALAR_FIELD(aggkind); - COMPARE_SCALAR_FIELD(agglevelsup); - COMPARE_SCALAR_FIELD(aggsplit); + COMPARE_BOOL_FIELD(aggstar); + COMPARE_BOOL_FIELD(aggvariadic); + COMPARE_CHAR_FIELD(aggkind); + COMPARE_UINT_FIELD(agglevelsup); + COMPARE_ENUM_FIELD(aggsplit, AggSplit); COMPARE_LOCATION_FIELD(location); return true; @@ -246,7 +256,7 @@ _equalGroupingFunc(const GroupingFunc *a, const GroupingFunc *b) * We must not compare the refs or cols field */ - COMPARE_SCALAR_FIELD(agglevelsup); + COMPARE_UINT_FIELD(agglevelsup); COMPARE_LOCATION_FIELD(location); return true; @@ -255,15 +265,15 @@ _equalGroupingFunc(const GroupingFunc *a, const GroupingFunc *b) static bool _equalWindowFunc(const WindowFunc *a, const WindowFunc *b) { - COMPARE_SCALAR_FIELD(winfnoid); - COMPARE_SCALAR_FIELD(wintype); - COMPARE_SCALAR_FIELD(wincollid); - COMPARE_SCALAR_FIELD(inputcollid); + COMPARE_OID_FIELD(winfnoid); + COMPARE_OID_FIELD(wintype); + COMPARE_OID_FIELD(wincollid); + COMPARE_OID_FIELD(inputcollid); COMPARE_NODE_FIELD(args); COMPARE_NODE_FIELD(aggfilter); - COMPARE_SCALAR_FIELD(winref); - COMPARE_SCALAR_FIELD(winstar); - COMPARE_SCALAR_FIELD(winagg); + COMPARE_UINT_FIELD(winref); + COMPARE_BOOL_FIELD(winstar); + COMPARE_BOOL_FIELD(winagg); COMPARE_LOCATION_FIELD(location); return true; @@ -272,10 +282,10 @@ _equalWindowFunc(const WindowFunc *a, const WindowFunc *b) static bool _equalSubscriptingRef(const SubscriptingRef *a, const SubscriptingRef *b) { - COMPARE_SCALAR_FIELD(refcontainertype); - COMPARE_SCALAR_FIELD(refelemtype); - COMPARE_SCALAR_FIELD(reftypmod); - COMPARE_SCALAR_FIELD(refcollid); + COMPARE_OID_FIELD(refcontainertype); + COMPARE_OID_FIELD(refelemtype); + COMPARE_INT_FIELD(reftypmod); + COMPARE_OID_FIELD(refcollid); COMPARE_NODE_FIELD(refupperindexpr); COMPARE_NODE_FIELD(reflowerindexpr); COMPARE_NODE_FIELD(refexpr); @@ -287,13 +297,13 @@ _equalSubscriptingRef(const SubscriptingRef *a, const SubscriptingRef *b) static bool _equalFuncExpr(const FuncExpr *a, const FuncExpr *b) { - COMPARE_SCALAR_FIELD(funcid); - COMPARE_SCALAR_FIELD(funcresulttype); - COMPARE_SCALAR_FIELD(funcretset); - COMPARE_SCALAR_FIELD(funcvariadic); + COMPARE_OID_FIELD(funcid); + COMPARE_OID_FIELD(funcresulttype); + COMPARE_BOOL_FIELD(funcretset); + COMPARE_BOOL_FIELD(funcvariadic); COMPARE_COERCIONFORM_FIELD(funcformat); - COMPARE_SCALAR_FIELD(funccollid); - COMPARE_SCALAR_FIELD(inputcollid); + COMPARE_OID_FIELD(funccollid); + COMPARE_OID_FIELD(inputcollid); COMPARE_NODE_FIELD(args); COMPARE_LOCATION_FIELD(location); @@ -305,7 +315,7 @@ _equalNamedArgExpr(const NamedArgExpr *a, const NamedArgExpr *b) { COMPARE_NODE_FIELD(arg); COMPARE_STRING_FIELD(name); - COMPARE_SCALAR_FIELD(argnumber); + COMPARE_INT_FIELD(argnumber); COMPARE_LOCATION_FIELD(location); return true; @@ -314,7 +324,7 @@ _equalNamedArgExpr(const NamedArgExpr *a, const NamedArgExpr *b) static bool _equalOpExpr(const OpExpr *a, const OpExpr *b) { - COMPARE_SCALAR_FIELD(opno); + COMPARE_OID_FIELD(opno); /* * Special-case opfuncid: it is allowable for it to differ if one node @@ -327,10 +337,10 @@ _equalOpExpr(const OpExpr *a, const OpExpr *b) b->opfuncid != 0) return false; - COMPARE_SCALAR_FIELD(opresulttype); - COMPARE_SCALAR_FIELD(opretset); - COMPARE_SCALAR_FIELD(opcollid); - COMPARE_SCALAR_FIELD(inputcollid); + COMPARE_OID_FIELD(opresulttype); + COMPARE_BOOL_FIELD(opretset); + COMPARE_OID_FIELD(opcollid); + COMPARE_OID_FIELD(inputcollid); COMPARE_NODE_FIELD(args); COMPARE_LOCATION_FIELD(location); @@ -340,7 +350,7 @@ _equalOpExpr(const OpExpr *a, const OpExpr *b) static bool _equalDistinctExpr(const DistinctExpr *a, const DistinctExpr *b) { - COMPARE_SCALAR_FIELD(opno); + COMPARE_OID_FIELD(opno); /* * Special-case opfuncid: it is allowable for it to differ if one node @@ -353,10 +363,10 @@ _equalDistinctExpr(const DistinctExpr *a, const DistinctExpr *b) b->opfuncid != 0) return false; - COMPARE_SCALAR_FIELD(opresulttype); - COMPARE_SCALAR_FIELD(opretset); - COMPARE_SCALAR_FIELD(opcollid); - COMPARE_SCALAR_FIELD(inputcollid); + COMPARE_OID_FIELD(opresulttype); + COMPARE_BOOL_FIELD(opretset); + COMPARE_OID_FIELD(opcollid); + COMPARE_OID_FIELD(inputcollid); COMPARE_NODE_FIELD(args); COMPARE_LOCATION_FIELD(location); @@ -366,7 +376,7 @@ _equalDistinctExpr(const DistinctExpr *a, const DistinctExpr *b) static bool _equalNullIfExpr(const NullIfExpr *a, const NullIfExpr *b) { - COMPARE_SCALAR_FIELD(opno); + COMPARE_OID_FIELD(opno); /* * Special-case opfuncid: it is allowable for it to differ if one node @@ -379,10 +389,10 @@ _equalNullIfExpr(const NullIfExpr *a, const NullIfExpr *b) b->opfuncid != 0) return false; - COMPARE_SCALAR_FIELD(opresulttype); - COMPARE_SCALAR_FIELD(opretset); - COMPARE_SCALAR_FIELD(opcollid); - COMPARE_SCALAR_FIELD(inputcollid); + COMPARE_OID_FIELD(opresulttype); + COMPARE_BOOL_FIELD(opretset); + COMPARE_OID_FIELD(opcollid); + COMPARE_OID_FIELD(inputcollid); COMPARE_NODE_FIELD(args); COMPARE_LOCATION_FIELD(location); @@ -392,7 +402,7 @@ _equalNullIfExpr(const NullIfExpr *a, const NullIfExpr *b) static bool _equalScalarArrayOpExpr(const ScalarArrayOpExpr *a, const ScalarArrayOpExpr *b) { - COMPARE_SCALAR_FIELD(opno); + COMPARE_OID_FIELD(opno); /* * Special-case opfuncid: it is allowable for it to differ if one node @@ -405,8 +415,8 @@ _equalScalarArrayOpExpr(const ScalarArrayOpExpr *a, const ScalarArrayOpExpr *b) b->opfuncid != 0) return false; - COMPARE_SCALAR_FIELD(useOr); - COMPARE_SCALAR_FIELD(inputcollid); + COMPARE_BOOL_FIELD(useOr); + COMPARE_OID_FIELD(inputcollid); COMPARE_NODE_FIELD(args); COMPARE_LOCATION_FIELD(location); @@ -416,7 +426,7 @@ _equalScalarArrayOpExpr(const ScalarArrayOpExpr *a, const ScalarArrayOpExpr *b) static bool _equalBoolExpr(const BoolExpr *a, const BoolExpr *b) { - COMPARE_SCALAR_FIELD(boolop); + COMPARE_ENUM_FIELD(boolop, BoolExprType); COMPARE_NODE_FIELD(args); COMPARE_LOCATION_FIELD(location); @@ -426,8 +436,8 @@ _equalBoolExpr(const BoolExpr *a, const BoolExpr *b) static bool _equalSubLink(const SubLink *a, const SubLink *b) { - COMPARE_SCALAR_FIELD(subLinkType); - COMPARE_SCALAR_FIELD(subLinkId); + COMPARE_ENUM_FIELD(subLinkType, SubLinkType); + COMPARE_INT_FIELD(subLinkId); COMPARE_NODE_FIELD(testexpr); COMPARE_NODE_FIELD(operName); COMPARE_NODE_FIELD(subselect); @@ -439,22 +449,22 @@ _equalSubLink(const SubLink *a, const SubLink *b) static bool _equalSubPlan(const SubPlan *a, const SubPlan *b) { - COMPARE_SCALAR_FIELD(subLinkType); + COMPARE_ENUM_FIELD(subLinkType, SubLinkType); COMPARE_NODE_FIELD(testexpr); COMPARE_NODE_FIELD(paramIds); - COMPARE_SCALAR_FIELD(plan_id); + COMPARE_INT_FIELD(plan_id); COMPARE_STRING_FIELD(plan_name); - COMPARE_SCALAR_FIELD(firstColType); - COMPARE_SCALAR_FIELD(firstColTypmod); - COMPARE_SCALAR_FIELD(firstColCollation); - COMPARE_SCALAR_FIELD(useHashTable); - COMPARE_SCALAR_FIELD(unknownEqFalse); - COMPARE_SCALAR_FIELD(parallel_safe); + COMPARE_OID_FIELD(firstColType); + COMPARE_INT_FIELD(firstColTypmod); + COMPARE_OID_FIELD(firstColCollation); + COMPARE_BOOL_FIELD(useHashTable); + COMPARE_BOOL_FIELD(unknownEqFalse); + COMPARE_BOOL_FIELD(parallel_safe); COMPARE_NODE_FIELD(setParam); COMPARE_NODE_FIELD(parParam); COMPARE_NODE_FIELD(args); - COMPARE_SCALAR_FIELD(startup_cost); - COMPARE_SCALAR_FIELD(per_call_cost); + COMPARE_DOUBLE_FIELD(startup_cost); + COMPARE_DOUBLE_FIELD(per_call_cost); return true; } @@ -471,10 +481,10 @@ static bool _equalFieldSelect(const FieldSelect *a, const FieldSelect *b) { COMPARE_NODE_FIELD(arg); - COMPARE_SCALAR_FIELD(fieldnum); - COMPARE_SCALAR_FIELD(resulttype); - COMPARE_SCALAR_FIELD(resulttypmod); - COMPARE_SCALAR_FIELD(resultcollid); + COMPARE_INT_FIELD(fieldnum); + COMPARE_OID_FIELD(resulttype); + COMPARE_INT_FIELD(resulttypmod); + COMPARE_OID_FIELD(resultcollid); return true; } @@ -485,7 +495,7 @@ _equalFieldStore(const FieldStore *a, const FieldStore *b) COMPARE_NODE_FIELD(arg); COMPARE_NODE_FIELD(newvals); COMPARE_NODE_FIELD(fieldnums); - COMPARE_SCALAR_FIELD(resulttype); + COMPARE_OID_FIELD(resulttype); return true; } @@ -494,9 +504,9 @@ static bool _equalRelabelType(const RelabelType *a, const RelabelType *b) { COMPARE_NODE_FIELD(arg); - COMPARE_SCALAR_FIELD(resulttype); - COMPARE_SCALAR_FIELD(resulttypmod); - COMPARE_SCALAR_FIELD(resultcollid); + COMPARE_OID_FIELD(resulttype); + COMPARE_INT_FIELD(resulttypmod); + COMPARE_OID_FIELD(resultcollid); COMPARE_COERCIONFORM_FIELD(relabelformat); COMPARE_LOCATION_FIELD(location); @@ -507,8 +517,8 @@ static bool _equalCoerceViaIO(const CoerceViaIO *a, const CoerceViaIO *b) { COMPARE_NODE_FIELD(arg); - COMPARE_SCALAR_FIELD(resulttype); - COMPARE_SCALAR_FIELD(resultcollid); + COMPARE_OID_FIELD(resulttype); + COMPARE_OID_FIELD(resultcollid); COMPARE_COERCIONFORM_FIELD(coerceformat); COMPARE_LOCATION_FIELD(location); @@ -520,9 +530,9 @@ _equalArrayCoerceExpr(const ArrayCoerceExpr *a, const ArrayCoerceExpr *b) { COMPARE_NODE_FIELD(arg); COMPARE_NODE_FIELD(elemexpr); - COMPARE_SCALAR_FIELD(resulttype); - COMPARE_SCALAR_FIELD(resulttypmod); - COMPARE_SCALAR_FIELD(resultcollid); + COMPARE_OID_FIELD(resulttype); + COMPARE_INT_FIELD(resulttypmod); + COMPARE_OID_FIELD(resultcollid); COMPARE_COERCIONFORM_FIELD(coerceformat); COMPARE_LOCATION_FIELD(location); @@ -533,7 +543,7 @@ static bool _equalConvertRowtypeExpr(const ConvertRowtypeExpr *a, const ConvertRowtypeExpr *b) { COMPARE_NODE_FIELD(arg); - COMPARE_SCALAR_FIELD(resulttype); + COMPARE_OID_FIELD(resulttype); COMPARE_COERCIONFORM_FIELD(convertformat); COMPARE_LOCATION_FIELD(location); @@ -544,7 +554,7 @@ static bool _equalCollateExpr(const CollateExpr *a, const CollateExpr *b) { COMPARE_NODE_FIELD(arg); - COMPARE_SCALAR_FIELD(collOid); + COMPARE_OID_FIELD(collOid); COMPARE_LOCATION_FIELD(location); return true; @@ -553,8 +563,8 @@ _equalCollateExpr(const CollateExpr *a, const CollateExpr *b) static bool _equalCaseExpr(const CaseExpr *a, const CaseExpr *b) { - COMPARE_SCALAR_FIELD(casetype); - COMPARE_SCALAR_FIELD(casecollid); + COMPARE_OID_FIELD(casetype); + COMPARE_OID_FIELD(casecollid); COMPARE_NODE_FIELD(arg); COMPARE_NODE_FIELD(args); COMPARE_NODE_FIELD(defresult); @@ -576,9 +586,9 @@ _equalCaseWhen(const CaseWhen *a, const CaseWhen *b) static bool _equalCaseTestExpr(const CaseTestExpr *a, const CaseTestExpr *b) { - COMPARE_SCALAR_FIELD(typeId); - COMPARE_SCALAR_FIELD(typeMod); - COMPARE_SCALAR_FIELD(collation); + COMPARE_OID_FIELD(typeId); + COMPARE_INT_FIELD(typeMod); + COMPARE_OID_FIELD(collation); return true; } @@ -586,11 +596,11 @@ _equalCaseTestExpr(const CaseTestExpr *a, const CaseTestExpr *b) static bool _equalArrayExpr(const ArrayExpr *a, const ArrayExpr *b) { - COMPARE_SCALAR_FIELD(array_typeid); - COMPARE_SCALAR_FIELD(array_collid); - COMPARE_SCALAR_FIELD(element_typeid); + COMPARE_OID_FIELD(array_typeid); + COMPARE_OID_FIELD(array_collid); + COMPARE_OID_FIELD(element_typeid); COMPARE_NODE_FIELD(elements); - COMPARE_SCALAR_FIELD(multidims); + COMPARE_BOOL_FIELD(multidims); COMPARE_LOCATION_FIELD(location); return true; @@ -600,7 +610,7 @@ static bool _equalRowExpr(const RowExpr *a, const RowExpr *b) { COMPARE_NODE_FIELD(args); - COMPARE_SCALAR_FIELD(row_typeid); + COMPARE_OID_FIELD(row_typeid); COMPARE_COERCIONFORM_FIELD(row_format); COMPARE_NODE_FIELD(colnames); COMPARE_LOCATION_FIELD(location); @@ -611,7 +621,7 @@ _equalRowExpr(const RowExpr *a, const RowExpr *b) static bool _equalRowCompareExpr(const RowCompareExpr *a, const RowCompareExpr *b) { - COMPARE_SCALAR_FIELD(rctype); + COMPARE_ENUM_FIELD(rctype, RowCompareType); COMPARE_NODE_FIELD(opnos); COMPARE_NODE_FIELD(opfamilies); COMPARE_NODE_FIELD(inputcollids); @@ -624,8 +634,8 @@ _equalRowCompareExpr(const RowCompareExpr *a, const RowCompareExpr *b) static bool _equalCoalesceExpr(const CoalesceExpr *a, const CoalesceExpr *b) { - COMPARE_SCALAR_FIELD(coalescetype); - COMPARE_SCALAR_FIELD(coalescecollid); + COMPARE_OID_FIELD(coalescetype); + COMPARE_OID_FIELD(coalescecollid); COMPARE_NODE_FIELD(args); COMPARE_LOCATION_FIELD(location); @@ -635,10 +645,10 @@ _equalCoalesceExpr(const CoalesceExpr *a, const CoalesceExpr *b) static bool _equalMinMaxExpr(const MinMaxExpr *a, const MinMaxExpr *b) { - COMPARE_SCALAR_FIELD(minmaxtype); - COMPARE_SCALAR_FIELD(minmaxcollid); - COMPARE_SCALAR_FIELD(inputcollid); - COMPARE_SCALAR_FIELD(op); + COMPARE_OID_FIELD(minmaxtype); + COMPARE_OID_FIELD(minmaxcollid); + COMPARE_OID_FIELD(inputcollid); + COMPARE_ENUM_FIELD(op, MinMaxOp); COMPARE_NODE_FIELD(args); COMPARE_LOCATION_FIELD(location); @@ -648,9 +658,9 @@ _equalMinMaxExpr(const MinMaxExpr *a, const MinMaxExpr *b) static bool _equalSQLValueFunction(const SQLValueFunction *a, const SQLValueFunction *b) { - COMPARE_SCALAR_FIELD(op); - COMPARE_SCALAR_FIELD(type); - COMPARE_SCALAR_FIELD(typmod); + COMPARE_ENUM_FIELD(op, SQLValueFunctionOp); + COMPARE_OID_FIELD(type); + COMPARE_INT_FIELD(typmod); COMPARE_LOCATION_FIELD(location); return true; @@ -659,14 +669,14 @@ _equalSQLValueFunction(const SQLValueFunction *a, const SQLValueFunction *b) static bool _equalXmlExpr(const XmlExpr *a, const XmlExpr *b) { - COMPARE_SCALAR_FIELD(op); + COMPARE_ENUM_FIELD(op, XmlExprOp); COMPARE_STRING_FIELD(name); COMPARE_NODE_FIELD(named_args); COMPARE_NODE_FIELD(arg_names); COMPARE_NODE_FIELD(args); - COMPARE_SCALAR_FIELD(xmloption); - COMPARE_SCALAR_FIELD(type); - COMPARE_SCALAR_FIELD(typmod); + COMPARE_ENUM_FIELD(xmloption, XmlOptionType); + COMPARE_OID_FIELD(type); + COMPARE_INT_FIELD(typmod); COMPARE_LOCATION_FIELD(location); return true; @@ -676,8 +686,8 @@ static bool _equalNullTest(const NullTest *a, const NullTest *b) { COMPARE_NODE_FIELD(arg); - COMPARE_SCALAR_FIELD(nulltesttype); - COMPARE_SCALAR_FIELD(argisrow); + COMPARE_ENUM_FIELD(nulltesttype, NullTestType); + COMPARE_BOOL_FIELD(argisrow); COMPARE_LOCATION_FIELD(location); return true; @@ -687,7 +697,7 @@ static bool _equalBooleanTest(const BooleanTest *a, const BooleanTest *b) { COMPARE_NODE_FIELD(arg); - COMPARE_SCALAR_FIELD(booltesttype); + COMPARE_ENUM_FIELD(booltesttype, BoolTestType); COMPARE_LOCATION_FIELD(location); return true; @@ -697,9 +707,9 @@ static bool _equalCoerceToDomain(const CoerceToDomain *a, const CoerceToDomain *b) { COMPARE_NODE_FIELD(arg); - COMPARE_SCALAR_FIELD(resulttype); - COMPARE_SCALAR_FIELD(resulttypmod); - COMPARE_SCALAR_FIELD(resultcollid); + COMPARE_OID_FIELD(resulttype); + COMPARE_INT_FIELD(resulttypmod); + COMPARE_OID_FIELD(resultcollid); COMPARE_COERCIONFORM_FIELD(coercionformat); COMPARE_LOCATION_FIELD(location); @@ -709,9 +719,9 @@ _equalCoerceToDomain(const CoerceToDomain *a, const CoerceToDomain *b) static bool _equalCoerceToDomainValue(const CoerceToDomainValue *a, const CoerceToDomainValue *b) { - COMPARE_SCALAR_FIELD(typeId); - COMPARE_SCALAR_FIELD(typeMod); - COMPARE_SCALAR_FIELD(collation); + COMPARE_OID_FIELD(typeId); + COMPARE_INT_FIELD(typeMod); + COMPARE_OID_FIELD(collation); COMPARE_LOCATION_FIELD(location); return true; @@ -720,9 +730,9 @@ _equalCoerceToDomainValue(const CoerceToDomainValue *a, const CoerceToDomainValu static bool _equalSetToDefault(const SetToDefault *a, const SetToDefault *b) { - COMPARE_SCALAR_FIELD(typeId); - COMPARE_SCALAR_FIELD(typeMod); - COMPARE_SCALAR_FIELD(collation); + COMPARE_OID_FIELD(typeId); + COMPARE_INT_FIELD(typeMod); + COMPARE_OID_FIELD(collation); COMPARE_LOCATION_FIELD(location); return true; @@ -731,9 +741,9 @@ _equalSetToDefault(const SetToDefault *a, const SetToDefault *b) static bool _equalCurrentOfExpr(const CurrentOfExpr *a, const CurrentOfExpr *b) { - COMPARE_SCALAR_FIELD(cvarno); + COMPARE_UINT_FIELD(cvarno); COMPARE_STRING_FIELD(cursor_name); - COMPARE_SCALAR_FIELD(cursor_param); + COMPARE_INT_FIELD(cursor_param); return true; } @@ -741,8 +751,8 @@ _equalCurrentOfExpr(const CurrentOfExpr *a, const CurrentOfExpr *b) static bool _equalNextValueExpr(const NextValueExpr *a, const NextValueExpr *b) { - COMPARE_SCALAR_FIELD(seqid); - COMPARE_SCALAR_FIELD(typeId); + COMPARE_OID_FIELD(seqid); + COMPARE_OID_FIELD(typeId); return true; } @@ -751,8 +761,8 @@ static bool _equalInferenceElem(const InferenceElem *a, const InferenceElem *b) { COMPARE_NODE_FIELD(expr); - COMPARE_SCALAR_FIELD(infercollid); - COMPARE_SCALAR_FIELD(inferopclass); + COMPARE_OID_FIELD(infercollid); + COMPARE_OID_FIELD(inferopclass); return true; } @@ -761,12 +771,12 @@ static bool _equalTargetEntry(const TargetEntry *a, const TargetEntry *b) { COMPARE_NODE_FIELD(expr); - COMPARE_SCALAR_FIELD(resno); + COMPARE_INT_FIELD(resno); COMPARE_STRING_FIELD(resname); - COMPARE_SCALAR_FIELD(ressortgroupref); - COMPARE_SCALAR_FIELD(resorigtbl); - COMPARE_SCALAR_FIELD(resorigcol); - COMPARE_SCALAR_FIELD(resjunk); + COMPARE_UINT_FIELD(ressortgroupref); + COMPARE_OID_FIELD(resorigtbl); + COMPARE_INT_FIELD(resorigcol); + COMPARE_BOOL_FIELD(resjunk); return true; } @@ -774,7 +784,7 @@ _equalTargetEntry(const TargetEntry *a, const TargetEntry *b) static bool _equalRangeTblRef(const RangeTblRef *a, const RangeTblRef *b) { - COMPARE_SCALAR_FIELD(rtindex); + COMPARE_INT_FIELD(rtindex); return true; } @@ -782,14 +792,14 @@ _equalRangeTblRef(const RangeTblRef *a, const RangeTblRef *b) static bool _equalJoinExpr(const JoinExpr *a, const JoinExpr *b) { - COMPARE_SCALAR_FIELD(jointype); - COMPARE_SCALAR_FIELD(isNatural); + COMPARE_ENUM_FIELD(jointype, JoinType); + COMPARE_BOOL_FIELD(isNatural); COMPARE_NODE_FIELD(larg); COMPARE_NODE_FIELD(rarg); COMPARE_NODE_FIELD(usingClause); COMPARE_NODE_FIELD(quals); COMPARE_NODE_FIELD(alias); - COMPARE_SCALAR_FIELD(rtindex); + COMPARE_INT_FIELD(rtindex); return true; } @@ -806,13 +816,13 @@ _equalFromExpr(const FromExpr *a, const FromExpr *b) static bool _equalOnConflictExpr(const OnConflictExpr *a, const OnConflictExpr *b) { - COMPARE_SCALAR_FIELD(action); + COMPARE_ENUM_FIELD(action, OnConflictAction); COMPARE_NODE_FIELD(arbiterElems); COMPARE_NODE_FIELD(arbiterWhere); - COMPARE_SCALAR_FIELD(constraint); + COMPARE_OID_FIELD(constraint); COMPARE_NODE_FIELD(onConflictSet); COMPARE_NODE_FIELD(onConflictWhere); - COMPARE_SCALAR_FIELD(exclRelIndex); + COMPARE_INT_FIELD(exclRelIndex); COMPARE_NODE_FIELD(exclRelTlist); return true; @@ -826,10 +836,10 @@ static bool _equalPathKey(const PathKey *a, const PathKey *b) { /* We assume pointer equality is sufficient to compare the eclasses */ - COMPARE_SCALAR_FIELD(pk_eclass); - COMPARE_SCALAR_FIELD(pk_opfamily); - COMPARE_SCALAR_FIELD(pk_strategy); - COMPARE_SCALAR_FIELD(pk_nulls_first); + COMPARE_POINTER_VALUE_FIELD(pk_eclass); + COMPARE_OID_FIELD(pk_opfamily); + COMPARE_INT_FIELD(pk_strategy); + COMPARE_BOOL_FIELD(pk_nulls_first); return true; } @@ -838,9 +848,9 @@ static bool _equalRestrictInfo(const RestrictInfo *a, const RestrictInfo *b) { COMPARE_NODE_FIELD(clause); - COMPARE_SCALAR_FIELD(is_pushed_down); - COMPARE_SCALAR_FIELD(outerjoin_delayed); - COMPARE_SCALAR_FIELD(security_level); + COMPARE_BOOL_FIELD(is_pushed_down); + COMPARE_BOOL_FIELD(outerjoin_delayed); + COMPARE_UINT_FIELD(security_level); COMPARE_BITMAPSET_FIELD(required_relids); COMPARE_BITMAPSET_FIELD(outer_relids); COMPARE_BITMAPSET_FIELD(nullable_relids); @@ -872,8 +882,8 @@ _equalPlaceHolderVar(const PlaceHolderVar *a, const PlaceHolderVar *b) * * COMPARE_BITMAPSET_FIELD(phrels); */ - COMPARE_SCALAR_FIELD(phid); - COMPARE_SCALAR_FIELD(phlevelsup); + COMPARE_UINT_FIELD(phid); + COMPARE_UINT_FIELD(phlevelsup); return true; } @@ -885,11 +895,11 @@ _equalSpecialJoinInfo(const SpecialJoinInfo *a, const SpecialJoinInfo *b) COMPARE_BITMAPSET_FIELD(min_righthand); COMPARE_BITMAPSET_FIELD(syn_lefthand); COMPARE_BITMAPSET_FIELD(syn_righthand); - COMPARE_SCALAR_FIELD(jointype); - COMPARE_SCALAR_FIELD(lhs_strict); - COMPARE_SCALAR_FIELD(delay_upper_joins); - COMPARE_SCALAR_FIELD(semi_can_btree); - COMPARE_SCALAR_FIELD(semi_can_hash); + COMPARE_ENUM_FIELD(jointype, JoinType); + COMPARE_BOOL_FIELD(lhs_strict); + COMPARE_BOOL_FIELD(delay_upper_joins); + COMPARE_BOOL_FIELD(semi_can_btree); + COMPARE_BOOL_FIELD(semi_can_hash); COMPARE_NODE_FIELD(semi_operators); COMPARE_NODE_FIELD(semi_rhs_exprs); @@ -899,14 +909,14 @@ _equalSpecialJoinInfo(const SpecialJoinInfo *a, const SpecialJoinInfo *b) static bool _equalAppendRelInfo(const AppendRelInfo *a, const AppendRelInfo *b) { - COMPARE_SCALAR_FIELD(parent_relid); - COMPARE_SCALAR_FIELD(child_relid); - COMPARE_SCALAR_FIELD(parent_reltype); - COMPARE_SCALAR_FIELD(child_reltype); + COMPARE_UINT_FIELD(parent_relid); + COMPARE_UINT_FIELD(child_relid); + COMPARE_OID_FIELD(parent_reltype); + COMPARE_OID_FIELD(child_reltype); COMPARE_NODE_FIELD(translated_vars); - COMPARE_SCALAR_FIELD(num_child_cols); + COMPARE_INT_FIELD(num_child_cols); COMPARE_POINTER_FIELD(parent_colnos, a->num_child_cols * sizeof(AttrNumber)); - COMPARE_SCALAR_FIELD(parent_reloid); + COMPARE_OID_FIELD(parent_reloid); return true; } @@ -914,12 +924,12 @@ _equalAppendRelInfo(const AppendRelInfo *a, const AppendRelInfo *b) static bool _equalPlaceHolderInfo(const PlaceHolderInfo *a, const PlaceHolderInfo *b) { - COMPARE_SCALAR_FIELD(phid); + COMPARE_UINT_FIELD(phid); COMPARE_NODE_FIELD(ph_var); /* should be redundant */ COMPARE_BITMAPSET_FIELD(ph_eval_at); COMPARE_BITMAPSET_FIELD(ph_lateral); COMPARE_BITMAPSET_FIELD(ph_needed); - COMPARE_SCALAR_FIELD(ph_width); + COMPARE_INT_FIELD(ph_width); return true; } @@ -951,26 +961,26 @@ _equalExtensibleNode(const ExtensibleNode *a, const ExtensibleNode *b) static bool _equalQuery(const Query *a, const Query *b) { - COMPARE_SCALAR_FIELD(commandType); - COMPARE_SCALAR_FIELD(querySource); + COMPARE_ENUM_FIELD(commandType, CmdType); + COMPARE_ENUM_FIELD(querySource, QuerySource); /* we intentionally ignore queryId, since it might not be set */ - COMPARE_SCALAR_FIELD(canSetTag); + COMPARE_BOOL_FIELD(canSetTag); COMPARE_NODE_FIELD(utilityStmt); - COMPARE_SCALAR_FIELD(resultRelation); - COMPARE_SCALAR_FIELD(hasAggs); - COMPARE_SCALAR_FIELD(hasWindowFuncs); - COMPARE_SCALAR_FIELD(hasTargetSRFs); - COMPARE_SCALAR_FIELD(hasSubLinks); - COMPARE_SCALAR_FIELD(hasDistinctOn); - COMPARE_SCALAR_FIELD(hasRecursive); - COMPARE_SCALAR_FIELD(hasModifyingCTE); - COMPARE_SCALAR_FIELD(hasForUpdate); - COMPARE_SCALAR_FIELD(hasRowSecurity); + COMPARE_INT_FIELD(resultRelation); + COMPARE_BOOL_FIELD(hasAggs); + COMPARE_BOOL_FIELD(hasWindowFuncs); + COMPARE_BOOL_FIELD(hasTargetSRFs); + COMPARE_BOOL_FIELD(hasSubLinks); + COMPARE_BOOL_FIELD(hasDistinctOn); + COMPARE_BOOL_FIELD(hasRecursive); + COMPARE_BOOL_FIELD(hasModifyingCTE); + COMPARE_BOOL_FIELD(hasForUpdate); + COMPARE_BOOL_FIELD(hasRowSecurity); COMPARE_NODE_FIELD(cteList); COMPARE_NODE_FIELD(rtable); COMPARE_NODE_FIELD(jointree); COMPARE_NODE_FIELD(targetList); - COMPARE_SCALAR_FIELD(override); + COMPARE_ENUM_FIELD(override, OverridingKind); COMPARE_NODE_FIELD(onConflict); COMPARE_NODE_FIELD(returningList); COMPARE_NODE_FIELD(groupClause); @@ -981,13 +991,13 @@ _equalQuery(const Query *a, const Query *b) COMPARE_NODE_FIELD(sortClause); COMPARE_NODE_FIELD(limitOffset); COMPARE_NODE_FIELD(limitCount); - COMPARE_SCALAR_FIELD(limitOption); + COMPARE_ENUM_FIELD(limitOption, LimitOption); COMPARE_NODE_FIELD(rowMarks); COMPARE_NODE_FIELD(setOperations); COMPARE_NODE_FIELD(constraintDeps); COMPARE_NODE_FIELD(withCheckOptions); COMPARE_LOCATION_FIELD(stmt_location); - COMPARE_SCALAR_FIELD(stmt_len); + COMPARE_INT_FIELD(stmt_len); return true; } @@ -997,7 +1007,7 @@ _equalRawStmt(const RawStmt *a, const RawStmt *b) { COMPARE_NODE_FIELD(stmt); COMPARE_LOCATION_FIELD(stmt_location); - COMPARE_SCALAR_FIELD(stmt_len); + COMPARE_INT_FIELD(stmt_len); return true; } @@ -1011,7 +1021,7 @@ _equalInsertStmt(const InsertStmt *a, const InsertStmt *b) COMPARE_NODE_FIELD(onConflictClause); COMPARE_NODE_FIELD(returningList); COMPARE_NODE_FIELD(withClause); - COMPARE_SCALAR_FIELD(override); + COMPARE_ENUM_FIELD(override, OverridingKind); return true; } @@ -1056,11 +1066,11 @@ _equalSelectStmt(const SelectStmt *a, const SelectStmt *b) COMPARE_NODE_FIELD(sortClause); COMPARE_NODE_FIELD(limitOffset); COMPARE_NODE_FIELD(limitCount); - COMPARE_SCALAR_FIELD(limitOption); + COMPARE_ENUM_FIELD(limitOption, LimitOption); COMPARE_NODE_FIELD(lockingClause); COMPARE_NODE_FIELD(withClause); - COMPARE_SCALAR_FIELD(op); - COMPARE_SCALAR_FIELD(all); + COMPARE_ENUM_FIELD(op, SetOperation); + COMPARE_BOOL_FIELD(all); COMPARE_NODE_FIELD(larg); COMPARE_NODE_FIELD(rarg); @@ -1070,8 +1080,8 @@ _equalSelectStmt(const SelectStmt *a, const SelectStmt *b) static bool _equalSetOperationStmt(const SetOperationStmt *a, const SetOperationStmt *b) { - COMPARE_SCALAR_FIELD(op); - COMPARE_SCALAR_FIELD(all); + COMPARE_ENUM_FIELD(op, SetOperation); + COMPARE_BOOL_FIELD(all); COMPARE_NODE_FIELD(larg); COMPARE_NODE_FIELD(rarg); COMPARE_NODE_FIELD(colTypes); @@ -1087,8 +1097,8 @@ _equalAlterTableStmt(const AlterTableStmt *a, const AlterTableStmt *b) { COMPARE_NODE_FIELD(relation); COMPARE_NODE_FIELD(cmds); - COMPARE_SCALAR_FIELD(relkind); - COMPARE_SCALAR_FIELD(missing_ok); + COMPARE_ENUM_FIELD(relkind, ObjectType); + COMPARE_BOOL_FIELD(missing_ok); return true; } @@ -1096,13 +1106,13 @@ _equalAlterTableStmt(const AlterTableStmt *a, const AlterTableStmt *b) static bool _equalAlterTableCmd(const AlterTableCmd *a, const AlterTableCmd *b) { - COMPARE_SCALAR_FIELD(subtype); + COMPARE_ENUM_FIELD(subtype, AlterTableType); COMPARE_STRING_FIELD(name); - COMPARE_SCALAR_FIELD(num); + COMPARE_INT_FIELD(num); COMPARE_NODE_FIELD(newowner); COMPARE_NODE_FIELD(def); - COMPARE_SCALAR_FIELD(behavior); - COMPARE_SCALAR_FIELD(missing_ok); + COMPARE_ENUM_FIELD(behavior, DropBehavior); + COMPARE_BOOL_FIELD(missing_ok); return true; } @@ -1118,12 +1128,12 @@ _equalAlterCollationStmt(const AlterCollationStmt *a, const AlterCollationStmt * static bool _equalAlterDomainStmt(const AlterDomainStmt *a, const AlterDomainStmt *b) { - COMPARE_SCALAR_FIELD(subtype); + COMPARE_CHAR_FIELD(subtype); COMPARE_NODE_FIELD(typeName); COMPARE_STRING_FIELD(name); COMPARE_NODE_FIELD(def); - COMPARE_SCALAR_FIELD(behavior); - COMPARE_SCALAR_FIELD(missing_ok); + COMPARE_ENUM_FIELD(behavior, DropBehavior); + COMPARE_BOOL_FIELD(missing_ok); return true; } @@ -1131,14 +1141,14 @@ _equalAlterDomainStmt(const AlterDomainStmt *a, const AlterDomainStmt *b) static bool _equalGrantStmt(const GrantStmt *a, const GrantStmt *b) { - COMPARE_SCALAR_FIELD(is_grant); - COMPARE_SCALAR_FIELD(targtype); - COMPARE_SCALAR_FIELD(objtype); + COMPARE_BOOL_FIELD(is_grant); + COMPARE_ENUM_FIELD(targtype, GrantTargetType); + COMPARE_ENUM_FIELD(objtype, ObjectType); COMPARE_NODE_FIELD(objects); COMPARE_NODE_FIELD(privileges); COMPARE_NODE_FIELD(grantees); - COMPARE_SCALAR_FIELD(grant_option); - COMPARE_SCALAR_FIELD(behavior); + COMPARE_BOOL_FIELD(grant_option); + COMPARE_ENUM_FIELD(behavior, DropBehavior); return true; } @@ -1148,7 +1158,7 @@ _equalObjectWithArgs(const ObjectWithArgs *a, const ObjectWithArgs *b) { COMPARE_NODE_FIELD(objname); COMPARE_NODE_FIELD(objargs); - COMPARE_SCALAR_FIELD(args_unspecified); + COMPARE_BOOL_FIELD(args_unspecified); return true; } @@ -1167,10 +1177,10 @@ _equalGrantRoleStmt(const GrantRoleStmt *a, const GrantRoleStmt *b) { COMPARE_NODE_FIELD(granted_roles); COMPARE_NODE_FIELD(grantee_roles); - COMPARE_SCALAR_FIELD(is_grant); - COMPARE_SCALAR_FIELD(admin_opt); + COMPARE_BOOL_FIELD(is_grant); + COMPARE_BOOL_FIELD(admin_opt); COMPARE_NODE_FIELD(grantor); - COMPARE_SCALAR_FIELD(behavior); + COMPARE_ENUM_FIELD(behavior, DropBehavior); return true; } @@ -1188,7 +1198,7 @@ static bool _equalDeclareCursorStmt(const DeclareCursorStmt *a, const DeclareCursorStmt *b) { COMPARE_STRING_FIELD(portalname); - COMPARE_SCALAR_FIELD(options); + COMPARE_INT_FIELD(options); COMPARE_NODE_FIELD(query); return true; @@ -1216,7 +1226,7 @@ _equalClusterStmt(const ClusterStmt *a, const ClusterStmt *b) { COMPARE_NODE_FIELD(relation); COMPARE_STRING_FIELD(indexname); - COMPARE_SCALAR_FIELD(options); + COMPARE_INT_FIELD(options); return true; } @@ -1227,8 +1237,8 @@ _equalCopyStmt(const CopyStmt *a, const CopyStmt *b) COMPARE_NODE_FIELD(relation); COMPARE_NODE_FIELD(query); COMPARE_NODE_FIELD(attlist); - COMPARE_SCALAR_FIELD(is_from); - COMPARE_SCALAR_FIELD(is_program); + COMPARE_BOOL_FIELD(is_from); + COMPARE_BOOL_FIELD(is_program); COMPARE_STRING_FIELD(filename); COMPARE_NODE_FIELD(options); COMPARE_NODE_FIELD(whereClause); @@ -1247,10 +1257,10 @@ _equalCreateStmt(const CreateStmt *a, const CreateStmt *b) COMPARE_NODE_FIELD(ofTypename); COMPARE_NODE_FIELD(constraints); COMPARE_NODE_FIELD(options); - COMPARE_SCALAR_FIELD(oncommit); + COMPARE_ENUM_FIELD(oncommit, OnCommitAction); COMPARE_STRING_FIELD(tablespacename); COMPARE_STRING_FIELD(accessMethod); - COMPARE_SCALAR_FIELD(if_not_exists); + COMPARE_BOOL_FIELD(if_not_exists); return true; } @@ -1259,7 +1269,7 @@ static bool _equalTableLikeClause(const TableLikeClause *a, const TableLikeClause *b) { COMPARE_NODE_FIELD(relation); - COMPARE_SCALAR_FIELD(options); + COMPARE_UINT_FIELD(options); return true; } @@ -1267,13 +1277,13 @@ _equalTableLikeClause(const TableLikeClause *a, const TableLikeClause *b) static bool _equalDefineStmt(const DefineStmt *a, const DefineStmt *b) { - COMPARE_SCALAR_FIELD(kind); - COMPARE_SCALAR_FIELD(oldstyle); + COMPARE_ENUM_FIELD(kind, ObjectType); + COMPARE_BOOL_FIELD(oldstyle); COMPARE_NODE_FIELD(defnames); COMPARE_NODE_FIELD(args); COMPARE_NODE_FIELD(definition); - COMPARE_SCALAR_FIELD(if_not_exists); - COMPARE_SCALAR_FIELD(replace); + COMPARE_BOOL_FIELD(if_not_exists); + COMPARE_BOOL_FIELD(replace); return true; } @@ -1282,10 +1292,10 @@ static bool _equalDropStmt(const DropStmt *a, const DropStmt *b) { COMPARE_NODE_FIELD(objects); - COMPARE_SCALAR_FIELD(removeType); - COMPARE_SCALAR_FIELD(behavior); - COMPARE_SCALAR_FIELD(missing_ok); - COMPARE_SCALAR_FIELD(concurrent); + COMPARE_ENUM_FIELD(removeType, ObjectType); + COMPARE_ENUM_FIELD(behavior, DropBehavior); + COMPARE_BOOL_FIELD(missing_ok); + COMPARE_BOOL_FIELD(concurrent); return true; } @@ -1294,8 +1304,8 @@ static bool _equalTruncateStmt(const TruncateStmt *a, const TruncateStmt *b) { COMPARE_NODE_FIELD(relations); - COMPARE_SCALAR_FIELD(restart_seqs); - COMPARE_SCALAR_FIELD(behavior); + COMPARE_BOOL_FIELD(restart_seqs); + COMPARE_ENUM_FIELD(behavior, DropBehavior); return true; } @@ -1303,7 +1313,7 @@ _equalTruncateStmt(const TruncateStmt *a, const TruncateStmt *b) static bool _equalCommentStmt(const CommentStmt *a, const CommentStmt *b) { - COMPARE_SCALAR_FIELD(objtype); + COMPARE_ENUM_FIELD(objtype, ObjectType); COMPARE_NODE_FIELD(object); COMPARE_STRING_FIELD(comment); @@ -1313,7 +1323,7 @@ _equalCommentStmt(const CommentStmt *a, const CommentStmt *b) static bool _equalSecLabelStmt(const SecLabelStmt *a, const SecLabelStmt *b) { - COMPARE_SCALAR_FIELD(objtype); + COMPARE_ENUM_FIELD(objtype, ObjectType); COMPARE_NODE_FIELD(object); COMPARE_STRING_FIELD(provider); COMPARE_STRING_FIELD(label); @@ -1324,10 +1334,10 @@ _equalSecLabelStmt(const SecLabelStmt *a, const SecLabelStmt *b) static bool _equalFetchStmt(const FetchStmt *a, const FetchStmt *b) { - COMPARE_SCALAR_FIELD(direction); - COMPARE_SCALAR_FIELD(howMany); + COMPARE_ENUM_FIELD(direction, FetchDirection); + COMPARE_LONG_FIELD(howMany); COMPARE_STRING_FIELD(portalname); - COMPARE_SCALAR_FIELD(ismove); + COMPARE_BOOL_FIELD(ismove); return true; } @@ -1345,19 +1355,19 @@ _equalIndexStmt(const IndexStmt *a, const IndexStmt *b) COMPARE_NODE_FIELD(whereClause); COMPARE_NODE_FIELD(excludeOpNames); COMPARE_STRING_FIELD(idxcomment); - COMPARE_SCALAR_FIELD(indexOid); - COMPARE_SCALAR_FIELD(oldNode); - COMPARE_SCALAR_FIELD(oldCreateSubid); - COMPARE_SCALAR_FIELD(oldFirstRelfilenodeSubid); - COMPARE_SCALAR_FIELD(unique); - COMPARE_SCALAR_FIELD(primary); - COMPARE_SCALAR_FIELD(isconstraint); - COMPARE_SCALAR_FIELD(deferrable); - COMPARE_SCALAR_FIELD(initdeferred); - COMPARE_SCALAR_FIELD(transformed); - COMPARE_SCALAR_FIELD(concurrent); - COMPARE_SCALAR_FIELD(if_not_exists); - COMPARE_SCALAR_FIELD(reset_default_tblspc); + COMPARE_OID_FIELD(indexOid); + COMPARE_OID_FIELD(oldNode); + COMPARE_UINT_FIELD(oldCreateSubid); + COMPARE_UINT_FIELD(oldFirstRelfilenodeSubid); + COMPARE_BOOL_FIELD(unique); + COMPARE_BOOL_FIELD(primary); + COMPARE_BOOL_FIELD(isconstraint); + COMPARE_BOOL_FIELD(deferrable); + COMPARE_BOOL_FIELD(initdeferred); + COMPARE_BOOL_FIELD(transformed); + COMPARE_BOOL_FIELD(concurrent); + COMPARE_BOOL_FIELD(if_not_exists); + COMPARE_BOOL_FIELD(reset_default_tblspc); return true; } @@ -1370,7 +1380,7 @@ _equalCreateStatsStmt(const CreateStatsStmt *a, const CreateStatsStmt *b) COMPARE_NODE_FIELD(exprs); COMPARE_NODE_FIELD(relations); COMPARE_STRING_FIELD(stxcomment); - COMPARE_SCALAR_FIELD(if_not_exists); + COMPARE_BOOL_FIELD(if_not_exists); return true; } @@ -1379,8 +1389,8 @@ static bool _equalAlterStatsStmt(const AlterStatsStmt *a, const AlterStatsStmt *b) { COMPARE_NODE_FIELD(defnames); - COMPARE_SCALAR_FIELD(stxstattarget); - COMPARE_SCALAR_FIELD(missing_ok); + COMPARE_INT_FIELD(stxstattarget); + COMPARE_BOOL_FIELD(missing_ok); return true; } @@ -1388,8 +1398,8 @@ _equalAlterStatsStmt(const AlterStatsStmt *a, const AlterStatsStmt *b) static bool _equalCreateFunctionStmt(const CreateFunctionStmt *a, const CreateFunctionStmt *b) { - COMPARE_SCALAR_FIELD(is_procedure); - COMPARE_SCALAR_FIELD(replace); + COMPARE_BOOL_FIELD(is_procedure); + COMPARE_BOOL_FIELD(replace); COMPARE_NODE_FIELD(funcname); COMPARE_NODE_FIELD(parameters); COMPARE_NODE_FIELD(returnType); @@ -1403,7 +1413,7 @@ _equalFunctionParameter(const FunctionParameter *a, const FunctionParameter *b) { COMPARE_STRING_FIELD(name); COMPARE_NODE_FIELD(argType); - COMPARE_SCALAR_FIELD(mode); + COMPARE_ENUM_FIELD(mode, FunctionParameterMode); COMPARE_NODE_FIELD(defexpr); return true; @@ -1412,7 +1422,7 @@ _equalFunctionParameter(const FunctionParameter *a, const FunctionParameter *b) static bool _equalAlterFunctionStmt(const AlterFunctionStmt *a, const AlterFunctionStmt *b) { - COMPARE_SCALAR_FIELD(objtype); + COMPARE_ENUM_FIELD(objtype, ObjectType); COMPARE_NODE_FIELD(func); COMPARE_NODE_FIELD(actions); @@ -1430,14 +1440,14 @@ _equalDoStmt(const DoStmt *a, const DoStmt *b) static bool _equalRenameStmt(const RenameStmt *a, const RenameStmt *b) { - COMPARE_SCALAR_FIELD(renameType); - COMPARE_SCALAR_FIELD(relationType); + COMPARE_ENUM_FIELD(renameType, ObjectType); + COMPARE_ENUM_FIELD(relationType, ObjectType); COMPARE_NODE_FIELD(relation); COMPARE_NODE_FIELD(object); COMPARE_STRING_FIELD(subname); COMPARE_STRING_FIELD(newname); - COMPARE_SCALAR_FIELD(behavior); - COMPARE_SCALAR_FIELD(missing_ok); + COMPARE_ENUM_FIELD(behavior, DropBehavior); + COMPARE_BOOL_FIELD(missing_ok); return true; } @@ -1445,11 +1455,11 @@ _equalRenameStmt(const RenameStmt *a, const RenameStmt *b) static bool _equalAlterObjectDependsStmt(const AlterObjectDependsStmt *a, const AlterObjectDependsStmt *b) { - COMPARE_SCALAR_FIELD(objectType); + COMPARE_ENUM_FIELD(objectType, ObjectType); COMPARE_NODE_FIELD(relation); COMPARE_NODE_FIELD(object); COMPARE_NODE_FIELD(extname); - COMPARE_SCALAR_FIELD(remove); + COMPARE_BOOL_FIELD(remove); return true; } @@ -1457,11 +1467,11 @@ _equalAlterObjectDependsStmt(const AlterObjectDependsStmt *a, const AlterObjectD static bool _equalAlterObjectSchemaStmt(const AlterObjectSchemaStmt *a, const AlterObjectSchemaStmt *b) { - COMPARE_SCALAR_FIELD(objectType); + COMPARE_ENUM_FIELD(objectType, ObjectType); COMPARE_NODE_FIELD(relation); COMPARE_NODE_FIELD(object); COMPARE_STRING_FIELD(newschema); - COMPARE_SCALAR_FIELD(missing_ok); + COMPARE_BOOL_FIELD(missing_ok); return true; } @@ -1469,7 +1479,7 @@ _equalAlterObjectSchemaStmt(const AlterObjectSchemaStmt *a, const AlterObjectSch static bool _equalAlterOwnerStmt(const AlterOwnerStmt *a, const AlterOwnerStmt *b) { - COMPARE_SCALAR_FIELD(objectType); + COMPARE_ENUM_FIELD(objectType, ObjectType); COMPARE_NODE_FIELD(relation); COMPARE_NODE_FIELD(object); COMPARE_NODE_FIELD(newowner); @@ -1501,10 +1511,10 @@ _equalRuleStmt(const RuleStmt *a, const RuleStmt *b) COMPARE_NODE_FIELD(relation); COMPARE_STRING_FIELD(rulename); COMPARE_NODE_FIELD(whereClause); - COMPARE_SCALAR_FIELD(event); - COMPARE_SCALAR_FIELD(instead); + COMPARE_ENUM_FIELD(event, CmdType); + COMPARE_BOOL_FIELD(instead); COMPARE_NODE_FIELD(actions); - COMPARE_SCALAR_FIELD(replace); + COMPARE_BOOL_FIELD(replace); return true; } @@ -1537,11 +1547,11 @@ _equalUnlistenStmt(const UnlistenStmt *a, const UnlistenStmt *b) static bool _equalTransactionStmt(const TransactionStmt *a, const TransactionStmt *b) { - COMPARE_SCALAR_FIELD(kind); + COMPARE_ENUM_FIELD(kind, TransactionStmtKind); COMPARE_NODE_FIELD(options); COMPARE_STRING_FIELD(savepoint_name); COMPARE_STRING_FIELD(gid); - COMPARE_SCALAR_FIELD(chain); + COMPARE_BOOL_FIELD(chain); return true; } @@ -1580,8 +1590,8 @@ _equalAlterEnumStmt(const AlterEnumStmt *a, const AlterEnumStmt *b) COMPARE_STRING_FIELD(oldVal); COMPARE_STRING_FIELD(newVal); COMPARE_STRING_FIELD(newValNeighbor); - COMPARE_SCALAR_FIELD(newValIsAfter); - COMPARE_SCALAR_FIELD(skipIfNewValExists); + COMPARE_BOOL_FIELD(newValIsAfter); + COMPARE_BOOL_FIELD(skipIfNewValExists); return true; } @@ -1592,9 +1602,9 @@ _equalViewStmt(const ViewStmt *a, const ViewStmt *b) COMPARE_NODE_FIELD(view); COMPARE_NODE_FIELD(aliases); COMPARE_NODE_FIELD(query); - COMPARE_SCALAR_FIELD(replace); + COMPARE_BOOL_FIELD(replace); COMPARE_NODE_FIELD(options); - COMPARE_SCALAR_FIELD(withCheckOption); + COMPARE_ENUM_FIELD(withCheckOption, ViewCheckOption); return true; } @@ -1626,7 +1636,7 @@ _equalCreateOpClassStmt(const CreateOpClassStmt *a, const CreateOpClassStmt *b) COMPARE_STRING_FIELD(amname); COMPARE_NODE_FIELD(datatype); COMPARE_NODE_FIELD(items); - COMPARE_SCALAR_FIELD(isDefault); + COMPARE_BOOL_FIELD(isDefault); return true; } @@ -1634,9 +1644,9 @@ _equalCreateOpClassStmt(const CreateOpClassStmt *a, const CreateOpClassStmt *b) static bool _equalCreateOpClassItem(const CreateOpClassItem *a, const CreateOpClassItem *b) { - COMPARE_SCALAR_FIELD(itemtype); + COMPARE_INT_FIELD(itemtype); COMPARE_NODE_FIELD(name); - COMPARE_SCALAR_FIELD(number); + COMPARE_INT_FIELD(number); COMPARE_NODE_FIELD(order_family); COMPARE_NODE_FIELD(class_args); COMPARE_NODE_FIELD(storedtype); @@ -1658,7 +1668,7 @@ _equalAlterOpFamilyStmt(const AlterOpFamilyStmt *a, const AlterOpFamilyStmt *b) { COMPARE_NODE_FIELD(opfamilyname); COMPARE_STRING_FIELD(amname); - COMPARE_SCALAR_FIELD(isDrop); + COMPARE_BOOL_FIELD(isDrop); COMPARE_NODE_FIELD(items); return true; @@ -1695,7 +1705,7 @@ static bool _equalDropdbStmt(const DropdbStmt *a, const DropdbStmt *b) { COMPARE_STRING_FIELD(dbname); - COMPARE_SCALAR_FIELD(missing_ok); + COMPARE_BOOL_FIELD(missing_ok); COMPARE_NODE_FIELD(options); return true; @@ -1706,7 +1716,7 @@ _equalVacuumStmt(const VacuumStmt *a, const VacuumStmt *b) { COMPARE_NODE_FIELD(options); COMPARE_NODE_FIELD(rels); - COMPARE_SCALAR_FIELD(is_vacuumcmd); + COMPARE_BOOL_FIELD(is_vacuumcmd); return true; } @@ -1715,7 +1725,7 @@ static bool _equalVacuumRelation(const VacuumRelation *a, const VacuumRelation *b) { COMPARE_NODE_FIELD(relation); - COMPARE_SCALAR_FIELD(oid); + COMPARE_OID_FIELD(oid); COMPARE_NODE_FIELD(va_cols); return true; @@ -1735,9 +1745,9 @@ _equalCreateTableAsStmt(const CreateTableAsStmt *a, const CreateTableAsStmt *b) { COMPARE_NODE_FIELD(query); COMPARE_NODE_FIELD(into); - COMPARE_SCALAR_FIELD(relkind); - COMPARE_SCALAR_FIELD(is_select_into); - COMPARE_SCALAR_FIELD(if_not_exists); + COMPARE_ENUM_FIELD(relkind, ObjectType); + COMPARE_BOOL_FIELD(is_select_into); + COMPARE_BOOL_FIELD(if_not_exists); return true; } @@ -1745,8 +1755,8 @@ _equalCreateTableAsStmt(const CreateTableAsStmt *a, const CreateTableAsStmt *b) static bool _equalRefreshMatViewStmt(const RefreshMatViewStmt *a, const RefreshMatViewStmt *b) { - COMPARE_SCALAR_FIELD(concurrent); - COMPARE_SCALAR_FIELD(skipData); + COMPARE_BOOL_FIELD(concurrent); + COMPARE_BOOL_FIELD(skipData); COMPARE_NODE_FIELD(relation); return true; @@ -1755,7 +1765,7 @@ _equalRefreshMatViewStmt(const RefreshMatViewStmt *a, const RefreshMatViewStmt * static bool _equalReplicaIdentityStmt(const ReplicaIdentityStmt *a, const ReplicaIdentityStmt *b) { - COMPARE_SCALAR_FIELD(identity_type); + COMPARE_CHAR_FIELD(identity_type); COMPARE_STRING_FIELD(name); return true; @@ -1775,9 +1785,9 @@ _equalCreateSeqStmt(const CreateSeqStmt *a, const CreateSeqStmt *b) { COMPARE_NODE_FIELD(sequence); COMPARE_NODE_FIELD(options); - COMPARE_SCALAR_FIELD(ownerId); - COMPARE_SCALAR_FIELD(for_identity); - COMPARE_SCALAR_FIELD(if_not_exists); + COMPARE_OID_FIELD(ownerId); + COMPARE_BOOL_FIELD(for_identity); + COMPARE_BOOL_FIELD(if_not_exists); return true; } @@ -1787,8 +1797,8 @@ _equalAlterSeqStmt(const AlterSeqStmt *a, const AlterSeqStmt *b) { COMPARE_NODE_FIELD(sequence); COMPARE_NODE_FIELD(options); - COMPARE_SCALAR_FIELD(for_identity); - COMPARE_SCALAR_FIELD(missing_ok); + COMPARE_BOOL_FIELD(for_identity); + COMPARE_BOOL_FIELD(missing_ok); return true; } @@ -1796,10 +1806,10 @@ _equalAlterSeqStmt(const AlterSeqStmt *a, const AlterSeqStmt *b) static bool _equalVariableSetStmt(const VariableSetStmt *a, const VariableSetStmt *b) { - COMPARE_SCALAR_FIELD(kind); + COMPARE_ENUM_FIELD(kind, VariableSetKind); COMPARE_STRING_FIELD(name); COMPARE_NODE_FIELD(args); - COMPARE_SCALAR_FIELD(is_local); + COMPARE_BOOL_FIELD(is_local); return true; } @@ -1815,7 +1825,7 @@ _equalVariableShowStmt(const VariableShowStmt *a, const VariableShowStmt *b) static bool _equalDiscardStmt(const DiscardStmt *a, const DiscardStmt *b) { - COMPARE_SCALAR_FIELD(target); + COMPARE_ENUM_FIELD(target, DiscardMode); return true; } @@ -1835,7 +1845,7 @@ static bool _equalDropTableSpaceStmt(const DropTableSpaceStmt *a, const DropTableSpaceStmt *b) { COMPARE_STRING_FIELD(tablespacename); - COMPARE_SCALAR_FIELD(missing_ok); + COMPARE_BOOL_FIELD(missing_ok); return true; } @@ -1846,7 +1856,7 @@ _equalAlterTableSpaceOptionsStmt(const AlterTableSpaceOptionsStmt *a, { COMPARE_STRING_FIELD(tablespacename); COMPARE_NODE_FIELD(options); - COMPARE_SCALAR_FIELD(isReset); + COMPARE_BOOL_FIELD(isReset); return true; } @@ -1856,10 +1866,10 @@ _equalAlterTableMoveAllStmt(const AlterTableMoveAllStmt *a, const AlterTableMoveAllStmt *b) { COMPARE_STRING_FIELD(orig_tablespacename); - COMPARE_SCALAR_FIELD(objtype); + COMPARE_ENUM_FIELD(objtype, ObjectType); COMPARE_NODE_FIELD(roles); COMPARE_STRING_FIELD(new_tablespacename); - COMPARE_SCALAR_FIELD(nowait); + COMPARE_BOOL_FIELD(nowait); return true; } @@ -1868,7 +1878,7 @@ static bool _equalCreateExtensionStmt(const CreateExtensionStmt *a, const CreateExtensionStmt *b) { COMPARE_STRING_FIELD(extname); - COMPARE_SCALAR_FIELD(if_not_exists); + COMPARE_BOOL_FIELD(if_not_exists); COMPARE_NODE_FIELD(options); return true; @@ -1887,8 +1897,8 @@ static bool _equalAlterExtensionContentsStmt(const AlterExtensionContentsStmt *a, const AlterExtensionContentsStmt *b) { COMPARE_STRING_FIELD(extname); - COMPARE_SCALAR_FIELD(action); - COMPARE_SCALAR_FIELD(objtype); + COMPARE_INT_FIELD(action); + COMPARE_ENUM_FIELD(objtype, ObjectType); COMPARE_NODE_FIELD(object); return true; @@ -1921,7 +1931,7 @@ _equalCreateForeignServerStmt(const CreateForeignServerStmt *a, const CreateFore COMPARE_STRING_FIELD(servertype); COMPARE_STRING_FIELD(version); COMPARE_STRING_FIELD(fdwname); - COMPARE_SCALAR_FIELD(if_not_exists); + COMPARE_BOOL_FIELD(if_not_exists); COMPARE_NODE_FIELD(options); return true; @@ -1933,7 +1943,7 @@ _equalAlterForeignServerStmt(const AlterForeignServerStmt *a, const AlterForeign COMPARE_STRING_FIELD(servername); COMPARE_STRING_FIELD(version); COMPARE_NODE_FIELD(options); - COMPARE_SCALAR_FIELD(has_version); + COMPARE_BOOL_FIELD(has_version); return true; } @@ -1943,7 +1953,7 @@ _equalCreateUserMappingStmt(const CreateUserMappingStmt *a, const CreateUserMapp { COMPARE_NODE_FIELD(user); COMPARE_STRING_FIELD(servername); - COMPARE_SCALAR_FIELD(if_not_exists); + COMPARE_BOOL_FIELD(if_not_exists); COMPARE_NODE_FIELD(options); return true; @@ -1964,7 +1974,7 @@ _equalDropUserMappingStmt(const DropUserMappingStmt *a, const DropUserMappingStm { COMPARE_NODE_FIELD(user); COMPARE_STRING_FIELD(servername); - COMPARE_SCALAR_FIELD(missing_ok); + COMPARE_BOOL_FIELD(missing_ok); return true; } @@ -1987,7 +1997,7 @@ _equalImportForeignSchemaStmt(const ImportForeignSchemaStmt *a, const ImportFore COMPARE_STRING_FIELD(server_name); COMPARE_STRING_FIELD(remote_schema); COMPARE_STRING_FIELD(local_schema); - COMPARE_SCALAR_FIELD(list_type); + COMPARE_ENUM_FIELD(list_type, ImportForeignSchemaType); COMPARE_NODE_FIELD(table_list); COMPARE_NODE_FIELD(options); @@ -1997,7 +2007,7 @@ _equalImportForeignSchemaStmt(const ImportForeignSchemaStmt *a, const ImportFore static bool _equalCreateTransformStmt(const CreateTransformStmt *a, const CreateTransformStmt *b) { - COMPARE_SCALAR_FIELD(replace); + COMPARE_BOOL_FIELD(replace); COMPARE_NODE_FIELD(type_name); COMPARE_STRING_FIELD(lang); COMPARE_NODE_FIELD(fromsql); @@ -2011,7 +2021,7 @@ _equalCreateAmStmt(const CreateAmStmt *a, const CreateAmStmt *b) { COMPARE_STRING_FIELD(amname); COMPARE_NODE_FIELD(handler_name); - COMPARE_SCALAR_FIELD(amtype); + COMPARE_CHAR_FIELD(amtype); return true; } @@ -2023,15 +2033,15 @@ _equalCreateTrigStmt(const CreateTrigStmt *a, const CreateTrigStmt *b) COMPARE_NODE_FIELD(relation); COMPARE_NODE_FIELD(funcname); COMPARE_NODE_FIELD(args); - COMPARE_SCALAR_FIELD(row); - COMPARE_SCALAR_FIELD(timing); - COMPARE_SCALAR_FIELD(events); + COMPARE_BOOL_FIELD(row); + COMPARE_INT_FIELD(timing); + COMPARE_INT_FIELD(events); COMPARE_NODE_FIELD(columns); COMPARE_NODE_FIELD(whenClause); - COMPARE_SCALAR_FIELD(isconstraint); + COMPARE_BOOL_FIELD(isconstraint); COMPARE_NODE_FIELD(transitionRels); - COMPARE_SCALAR_FIELD(deferrable); - COMPARE_SCALAR_FIELD(initdeferred); + COMPARE_BOOL_FIELD(deferrable); + COMPARE_BOOL_FIELD(initdeferred); COMPARE_NODE_FIELD(constrrel); return true; @@ -2052,7 +2062,7 @@ static bool _equalAlterEventTrigStmt(const AlterEventTrigStmt *a, const AlterEventTrigStmt *b) { COMPARE_STRING_FIELD(trigname); - COMPARE_SCALAR_FIELD(tgenabled); + COMPARE_CHAR_FIELD(tgenabled); return true; } @@ -2060,12 +2070,12 @@ _equalAlterEventTrigStmt(const AlterEventTrigStmt *a, const AlterEventTrigStmt * static bool _equalCreatePLangStmt(const CreatePLangStmt *a, const CreatePLangStmt *b) { - COMPARE_SCALAR_FIELD(replace); + COMPARE_BOOL_FIELD(replace); COMPARE_STRING_FIELD(plname); COMPARE_NODE_FIELD(plhandler); COMPARE_NODE_FIELD(plinline); COMPARE_NODE_FIELD(plvalidator); - COMPARE_SCALAR_FIELD(pltrusted); + COMPARE_BOOL_FIELD(pltrusted); return true; } @@ -2073,7 +2083,7 @@ _equalCreatePLangStmt(const CreatePLangStmt *a, const CreatePLangStmt *b) static bool _equalCreateRoleStmt(const CreateRoleStmt *a, const CreateRoleStmt *b) { - COMPARE_SCALAR_FIELD(stmt_type); + COMPARE_ENUM_FIELD(stmt_type, RoleStmtType); COMPARE_STRING_FIELD(role); COMPARE_NODE_FIELD(options); @@ -2085,7 +2095,7 @@ _equalAlterRoleStmt(const AlterRoleStmt *a, const AlterRoleStmt *b) { COMPARE_NODE_FIELD(role); COMPARE_NODE_FIELD(options); - COMPARE_SCALAR_FIELD(action); + COMPARE_INT_FIELD(action); return true; } @@ -2104,7 +2114,7 @@ static bool _equalDropRoleStmt(const DropRoleStmt *a, const DropRoleStmt *b) { COMPARE_NODE_FIELD(roles); - COMPARE_SCALAR_FIELD(missing_ok); + COMPARE_BOOL_FIELD(missing_ok); return true; } @@ -2113,8 +2123,8 @@ static bool _equalLockStmt(const LockStmt *a, const LockStmt *b) { COMPARE_NODE_FIELD(relations); - COMPARE_SCALAR_FIELD(mode); - COMPARE_SCALAR_FIELD(nowait); + COMPARE_INT_FIELD(mode); + COMPARE_BOOL_FIELD(nowait); return true; } @@ -2123,7 +2133,7 @@ static bool _equalConstraintsSetStmt(const ConstraintsSetStmt *a, const ConstraintsSetStmt *b) { COMPARE_NODE_FIELD(constraints); - COMPARE_SCALAR_FIELD(deferred); + COMPARE_BOOL_FIELD(deferred); return true; } @@ -2131,11 +2141,11 @@ _equalConstraintsSetStmt(const ConstraintsSetStmt *a, const ConstraintsSetStmt * static bool _equalReindexStmt(const ReindexStmt *a, const ReindexStmt *b) { - COMPARE_SCALAR_FIELD(kind); + COMPARE_ENUM_FIELD(kind, ReindexObjectType); COMPARE_NODE_FIELD(relation); COMPARE_STRING_FIELD(name); - COMPARE_SCALAR_FIELD(options); - COMPARE_SCALAR_FIELD(concurrent); + COMPARE_INT_FIELD(options); + COMPARE_BOOL_FIELD(concurrent); return true; } @@ -2146,7 +2156,7 @@ _equalCreateSchemaStmt(const CreateSchemaStmt *a, const CreateSchemaStmt *b) COMPARE_STRING_FIELD(schemaname); COMPARE_NODE_FIELD(authrole); COMPARE_NODE_FIELD(schemaElts); - COMPARE_SCALAR_FIELD(if_not_exists); + COMPARE_BOOL_FIELD(if_not_exists); return true; } @@ -2158,7 +2168,7 @@ _equalCreateConversionStmt(const CreateConversionStmt *a, const CreateConversion COMPARE_STRING_FIELD(for_encoding_name); COMPARE_STRING_FIELD(to_encoding_name); COMPARE_NODE_FIELD(func_name); - COMPARE_SCALAR_FIELD(def); + COMPARE_BOOL_FIELD(def); return true; } @@ -2169,8 +2179,8 @@ _equalCreateCastStmt(const CreateCastStmt *a, const CreateCastStmt *b) COMPARE_NODE_FIELD(sourcetype); COMPARE_NODE_FIELD(targettype); COMPARE_NODE_FIELD(func); - COMPARE_SCALAR_FIELD(context); - COMPARE_SCALAR_FIELD(inout); + COMPARE_ENUM_FIELD(context, CoercionContext); + COMPARE_BOOL_FIELD(inout); return true; } @@ -2206,7 +2216,7 @@ static bool _equalDropOwnedStmt(const DropOwnedStmt *a, const DropOwnedStmt *b) { COMPARE_NODE_FIELD(roles); - COMPARE_SCALAR_FIELD(behavior); + COMPARE_ENUM_FIELD(behavior, DropBehavior); return true; } @@ -2233,13 +2243,13 @@ static bool _equalAlterTSConfigurationStmt(const AlterTSConfigurationStmt *a, const AlterTSConfigurationStmt *b) { - COMPARE_SCALAR_FIELD(kind); + COMPARE_ENUM_FIELD(kind, AlterTSConfigType); COMPARE_NODE_FIELD(cfgname); COMPARE_NODE_FIELD(tokentype); COMPARE_NODE_FIELD(dicts); - COMPARE_SCALAR_FIELD(override); - COMPARE_SCALAR_FIELD(replace); - COMPARE_SCALAR_FIELD(missing_ok); + COMPARE_BOOL_FIELD(override); + COMPARE_BOOL_FIELD(replace); + COMPARE_BOOL_FIELD(missing_ok); return true; } @@ -2251,7 +2261,7 @@ _equalCreatePublicationStmt(const CreatePublicationStmt *a, COMPARE_STRING_FIELD(pubname); COMPARE_NODE_FIELD(options); COMPARE_NODE_FIELD(tables); - COMPARE_SCALAR_FIELD(for_all_tables); + COMPARE_BOOL_FIELD(for_all_tables); return true; } @@ -2263,8 +2273,8 @@ _equalAlterPublicationStmt(const AlterPublicationStmt *a, COMPARE_STRING_FIELD(pubname); COMPARE_NODE_FIELD(options); COMPARE_NODE_FIELD(tables); - COMPARE_SCALAR_FIELD(for_all_tables); - COMPARE_SCALAR_FIELD(tableAction); + COMPARE_BOOL_FIELD(for_all_tables); + COMPARE_ENUM_FIELD(tableAction, DefElemAction); return true; } @@ -2285,7 +2295,7 @@ static bool _equalAlterSubscriptionStmt(const AlterSubscriptionStmt *a, const AlterSubscriptionStmt *b) { - COMPARE_SCALAR_FIELD(kind); + COMPARE_ENUM_FIELD(kind, AlterSubscriptionType); COMPARE_STRING_FIELD(subname); COMPARE_STRING_FIELD(conninfo); COMPARE_NODE_FIELD(publication); @@ -2299,8 +2309,8 @@ _equalDropSubscriptionStmt(const DropSubscriptionStmt *a, const DropSubscriptionStmt *b) { COMPARE_STRING_FIELD(subname); - COMPARE_SCALAR_FIELD(missing_ok); - COMPARE_SCALAR_FIELD(behavior); + COMPARE_BOOL_FIELD(missing_ok); + COMPARE_ENUM_FIELD(behavior, DropBehavior); return true; } @@ -2311,7 +2321,7 @@ _equalCreatePolicyStmt(const CreatePolicyStmt *a, const CreatePolicyStmt *b) COMPARE_STRING_FIELD(policy_name); COMPARE_NODE_FIELD(table); COMPARE_STRING_FIELD(cmd_name); - COMPARE_SCALAR_FIELD(permissive); + COMPARE_BOOL_FIELD(permissive); COMPARE_NODE_FIELD(roles); COMPARE_NODE_FIELD(qual); COMPARE_NODE_FIELD(with_check); @@ -2334,7 +2344,7 @@ _equalAlterPolicyStmt(const AlterPolicyStmt *a, const AlterPolicyStmt *b) static bool _equalAExpr(const A_Expr *a, const A_Expr *b) { - COMPARE_SCALAR_FIELD(kind); + COMPARE_ENUM_FIELD(kind, A_Expr_Kind); COMPARE_NODE_FIELD(name); COMPARE_NODE_FIELD(lexpr); COMPARE_NODE_FIELD(rexpr); @@ -2355,7 +2365,7 @@ _equalColumnRef(const ColumnRef *a, const ColumnRef *b) static bool _equalParamRef(const ParamRef *a, const ParamRef *b) { - COMPARE_SCALAR_FIELD(number); + COMPARE_INT_FIELD(number); COMPARE_LOCATION_FIELD(location); return true; @@ -2378,10 +2388,10 @@ _equalFuncCall(const FuncCall *a, const FuncCall *b) COMPARE_NODE_FIELD(args); COMPARE_NODE_FIELD(agg_order); COMPARE_NODE_FIELD(agg_filter); - COMPARE_SCALAR_FIELD(agg_within_group); - COMPARE_SCALAR_FIELD(agg_star); - COMPARE_SCALAR_FIELD(agg_distinct); - COMPARE_SCALAR_FIELD(func_variadic); + COMPARE_BOOL_FIELD(agg_within_group); + COMPARE_BOOL_FIELD(agg_star); + COMPARE_BOOL_FIELD(agg_distinct); + COMPARE_BOOL_FIELD(func_variadic); COMPARE_NODE_FIELD(over); COMPARE_LOCATION_FIELD(location); @@ -2397,7 +2407,7 @@ _equalAStar(const A_Star *a, const A_Star *b) static bool _equalAIndices(const A_Indices *a, const A_Indices *b) { - COMPARE_SCALAR_FIELD(is_slice); + COMPARE_BOOL_FIELD(is_slice); COMPARE_NODE_FIELD(lidx); COMPARE_NODE_FIELD(uidx); @@ -2437,8 +2447,8 @@ static bool _equalMultiAssignRef(const MultiAssignRef *a, const MultiAssignRef *b) { COMPARE_NODE_FIELD(source); - COMPARE_SCALAR_FIELD(colno); - COMPARE_SCALAR_FIELD(ncolumns); + COMPARE_INT_FIELD(colno); + COMPARE_INT_FIELD(ncolumns); return true; } @@ -2447,11 +2457,11 @@ static bool _equalTypeName(const TypeName *a, const TypeName *b) { COMPARE_NODE_FIELD(names); - COMPARE_SCALAR_FIELD(typeOid); - COMPARE_SCALAR_FIELD(setof); - COMPARE_SCALAR_FIELD(pct_type); + COMPARE_OID_FIELD(typeOid); + COMPARE_BOOL_FIELD(setof); + COMPARE_BOOL_FIELD(pct_type); COMPARE_NODE_FIELD(typmods); - COMPARE_SCALAR_FIELD(typemod); + COMPARE_INT_FIELD(typemod); COMPARE_NODE_FIELD(arrayBounds); COMPARE_LOCATION_FIELD(location); @@ -2482,8 +2492,8 @@ static bool _equalSortBy(const SortBy *a, const SortBy *b) { COMPARE_NODE_FIELD(node); - COMPARE_SCALAR_FIELD(sortby_dir); - COMPARE_SCALAR_FIELD(sortby_nulls); + COMPARE_ENUM_FIELD(sortby_dir, SortByDir); + COMPARE_ENUM_FIELD(sortby_nulls, SortByNulls); COMPARE_NODE_FIELD(useOp); COMPARE_LOCATION_FIELD(location); @@ -2497,7 +2507,7 @@ _equalWindowDef(const WindowDef *a, const WindowDef *b) COMPARE_STRING_FIELD(refname); COMPARE_NODE_FIELD(partitionClause); COMPARE_NODE_FIELD(orderClause); - COMPARE_SCALAR_FIELD(frameOptions); + COMPARE_INT_FIELD(frameOptions); COMPARE_NODE_FIELD(startOffset); COMPARE_NODE_FIELD(endOffset); COMPARE_LOCATION_FIELD(location); @@ -2508,7 +2518,7 @@ _equalWindowDef(const WindowDef *a, const WindowDef *b) static bool _equalRangeSubselect(const RangeSubselect *a, const RangeSubselect *b) { - COMPARE_SCALAR_FIELD(lateral); + COMPARE_BOOL_FIELD(lateral); COMPARE_NODE_FIELD(subquery); COMPARE_NODE_FIELD(alias); @@ -2518,9 +2528,9 @@ _equalRangeSubselect(const RangeSubselect *a, const RangeSubselect *b) static bool _equalRangeFunction(const RangeFunction *a, const RangeFunction *b) { - COMPARE_SCALAR_FIELD(lateral); - COMPARE_SCALAR_FIELD(ordinality); - COMPARE_SCALAR_FIELD(is_rowsfrom); + COMPARE_BOOL_FIELD(lateral); + COMPARE_BOOL_FIELD(ordinality); + COMPARE_BOOL_FIELD(is_rowsfrom); COMPARE_NODE_FIELD(functions); COMPARE_NODE_FIELD(alias); COMPARE_NODE_FIELD(coldeflist); @@ -2543,7 +2553,7 @@ _equalRangeTableSample(const RangeTableSample *a, const RangeTableSample *b) static bool _equalRangeTableFunc(const RangeTableFunc *a, const RangeTableFunc *b) { - COMPARE_SCALAR_FIELD(lateral); + COMPARE_BOOL_FIELD(lateral); COMPARE_NODE_FIELD(docexpr); COMPARE_NODE_FIELD(rowexpr); COMPARE_NODE_FIELD(namespaces); @@ -2559,8 +2569,8 @@ _equalRangeTableFuncCol(const RangeTableFuncCol *a, const RangeTableFuncCol *b) { COMPARE_STRING_FIELD(colname); COMPARE_NODE_FIELD(typeName); - COMPARE_SCALAR_FIELD(for_ordinality); - COMPARE_SCALAR_FIELD(is_not_null); + COMPARE_BOOL_FIELD(for_ordinality); + COMPARE_BOOL_FIELD(is_not_null); COMPARE_NODE_FIELD(colexpr); COMPARE_NODE_FIELD(coldefexpr); COMPARE_LOCATION_FIELD(location); @@ -2578,8 +2588,8 @@ _equalIndexElem(const IndexElem *a, const IndexElem *b) COMPARE_NODE_FIELD(collation); COMPARE_NODE_FIELD(opclass); COMPARE_NODE_FIELD(opclassopts); - COMPARE_SCALAR_FIELD(ordering); - COMPARE_SCALAR_FIELD(nulls_ordering); + COMPARE_ENUM_FIELD(ordering, SortByDir); + COMPARE_ENUM_FIELD(nulls_ordering, SortByNulls); return true; } @@ -2589,18 +2599,18 @@ _equalColumnDef(const ColumnDef *a, const ColumnDef *b) { COMPARE_STRING_FIELD(colname); COMPARE_NODE_FIELD(typeName); - COMPARE_SCALAR_FIELD(inhcount); - COMPARE_SCALAR_FIELD(is_local); - COMPARE_SCALAR_FIELD(is_not_null); - COMPARE_SCALAR_FIELD(is_from_type); - COMPARE_SCALAR_FIELD(storage); + COMPARE_INT_FIELD(inhcount); + COMPARE_BOOL_FIELD(is_local); + COMPARE_BOOL_FIELD(is_not_null); + COMPARE_BOOL_FIELD(is_from_type); + COMPARE_CHAR_FIELD(storage); COMPARE_NODE_FIELD(raw_default); COMPARE_NODE_FIELD(cooked_default); - COMPARE_SCALAR_FIELD(identity); + COMPARE_CHAR_FIELD(identity); COMPARE_NODE_FIELD(identitySequence); - COMPARE_SCALAR_FIELD(generated); + COMPARE_CHAR_FIELD(generated); COMPARE_NODE_FIELD(collClause); - COMPARE_SCALAR_FIELD(collOid); + COMPARE_OID_FIELD(collOid); COMPARE_NODE_FIELD(constraints); COMPARE_NODE_FIELD(fdwoptions); COMPARE_LOCATION_FIELD(location); @@ -2611,34 +2621,34 @@ _equalColumnDef(const ColumnDef *a, const ColumnDef *b) static bool _equalConstraint(const Constraint *a, const Constraint *b) { - COMPARE_SCALAR_FIELD(contype); + COMPARE_ENUM_FIELD(contype, ConstrType); COMPARE_STRING_FIELD(conname); - COMPARE_SCALAR_FIELD(deferrable); - COMPARE_SCALAR_FIELD(initdeferred); + COMPARE_BOOL_FIELD(deferrable); + COMPARE_BOOL_FIELD(initdeferred); COMPARE_LOCATION_FIELD(location); - COMPARE_SCALAR_FIELD(is_no_inherit); + COMPARE_BOOL_FIELD(is_no_inherit); COMPARE_NODE_FIELD(raw_expr); COMPARE_STRING_FIELD(cooked_expr); - COMPARE_SCALAR_FIELD(generated_when); + COMPARE_CHAR_FIELD(generated_when); COMPARE_NODE_FIELD(keys); COMPARE_NODE_FIELD(including); COMPARE_NODE_FIELD(exclusions); COMPARE_NODE_FIELD(options); COMPARE_STRING_FIELD(indexname); COMPARE_STRING_FIELD(indexspace); - COMPARE_SCALAR_FIELD(reset_default_tblspc); + COMPARE_BOOL_FIELD(reset_default_tblspc); COMPARE_STRING_FIELD(access_method); COMPARE_NODE_FIELD(where_clause); COMPARE_NODE_FIELD(pktable); COMPARE_NODE_FIELD(fk_attrs); COMPARE_NODE_FIELD(pk_attrs); - COMPARE_SCALAR_FIELD(fk_matchtype); - COMPARE_SCALAR_FIELD(fk_upd_action); - COMPARE_SCALAR_FIELD(fk_del_action); + COMPARE_CHAR_FIELD(fk_matchtype); + COMPARE_CHAR_FIELD(fk_upd_action); + COMPARE_CHAR_FIELD(fk_del_action); COMPARE_NODE_FIELD(old_conpfeqop); - COMPARE_SCALAR_FIELD(old_pktable_oid); - COMPARE_SCALAR_FIELD(skip_validation); - COMPARE_SCALAR_FIELD(initially_valid); + COMPARE_OID_FIELD(old_pktable_oid); + COMPARE_BOOL_FIELD(skip_validation); + COMPARE_BOOL_FIELD(initially_valid); return true; } @@ -2649,7 +2659,7 @@ _equalDefElem(const DefElem *a, const DefElem *b) COMPARE_STRING_FIELD(defnamespace); COMPARE_STRING_FIELD(defname); COMPARE_NODE_FIELD(arg); - COMPARE_SCALAR_FIELD(defaction); + COMPARE_ENUM_FIELD(defaction, DefElemAction); COMPARE_LOCATION_FIELD(location); return true; @@ -2659,8 +2669,8 @@ static bool _equalLockingClause(const LockingClause *a, const LockingClause *b) { COMPARE_NODE_FIELD(lockedRels); - COMPARE_SCALAR_FIELD(strength); - COMPARE_SCALAR_FIELD(waitPolicy); + COMPARE_ENUM_FIELD(strength, LockClauseStrength); + COMPARE_ENUM_FIELD(waitPolicy, LockWaitPolicy); return true; } @@ -2668,37 +2678,37 @@ _equalLockingClause(const LockingClause *a, const LockingClause *b) static bool _equalRangeTblEntry(const RangeTblEntry *a, const RangeTblEntry *b) { - COMPARE_SCALAR_FIELD(rtekind); - COMPARE_SCALAR_FIELD(relid); - COMPARE_SCALAR_FIELD(relkind); - COMPARE_SCALAR_FIELD(rellockmode); + COMPARE_ENUM_FIELD(rtekind, RTEKind); + COMPARE_OID_FIELD(relid); + COMPARE_CHAR_FIELD(relkind); + COMPARE_INT_FIELD(rellockmode); COMPARE_NODE_FIELD(tablesample); COMPARE_NODE_FIELD(subquery); - COMPARE_SCALAR_FIELD(security_barrier); - COMPARE_SCALAR_FIELD(jointype); - COMPARE_SCALAR_FIELD(joinmergedcols); + COMPARE_BOOL_FIELD(security_barrier); + COMPARE_ENUM_FIELD(jointype, JoinType); + COMPARE_INT_FIELD(joinmergedcols); COMPARE_NODE_FIELD(joinaliasvars); COMPARE_NODE_FIELD(joinleftcols); COMPARE_NODE_FIELD(joinrightcols); COMPARE_NODE_FIELD(functions); - COMPARE_SCALAR_FIELD(funcordinality); + COMPARE_BOOL_FIELD(funcordinality); COMPARE_NODE_FIELD(tablefunc); COMPARE_NODE_FIELD(values_lists); COMPARE_STRING_FIELD(ctename); - COMPARE_SCALAR_FIELD(ctelevelsup); - COMPARE_SCALAR_FIELD(self_reference); + COMPARE_UINT_FIELD(ctelevelsup); + COMPARE_BOOL_FIELD(self_reference); COMPARE_NODE_FIELD(coltypes); COMPARE_NODE_FIELD(coltypmods); COMPARE_NODE_FIELD(colcollations); COMPARE_STRING_FIELD(enrname); - COMPARE_SCALAR_FIELD(enrtuples); + COMPARE_DOUBLE_FIELD(enrtuples); COMPARE_NODE_FIELD(alias); COMPARE_NODE_FIELD(eref); - COMPARE_SCALAR_FIELD(lateral); - COMPARE_SCALAR_FIELD(inh); - COMPARE_SCALAR_FIELD(inFromCl); - COMPARE_SCALAR_FIELD(requiredPerms); - COMPARE_SCALAR_FIELD(checkAsUser); + COMPARE_BOOL_FIELD(lateral); + COMPARE_BOOL_FIELD(inh); + COMPARE_BOOL_FIELD(inFromCl); + COMPARE_ENUM_FIELD(requiredPerms, AclMode); + COMPARE_OID_FIELD(checkAsUser); COMPARE_BITMAPSET_FIELD(selectedCols); COMPARE_BITMAPSET_FIELD(insertedCols); COMPARE_BITMAPSET_FIELD(updatedCols); @@ -2712,7 +2722,7 @@ static bool _equalRangeTblFunction(const RangeTblFunction *a, const RangeTblFunction *b) { COMPARE_NODE_FIELD(funcexpr); - COMPARE_SCALAR_FIELD(funccolcount); + COMPARE_INT_FIELD(funccolcount); COMPARE_NODE_FIELD(funccolnames); COMPARE_NODE_FIELD(funccoltypes); COMPARE_NODE_FIELD(funccoltypmods); @@ -2725,7 +2735,7 @@ _equalRangeTblFunction(const RangeTblFunction *a, const RangeTblFunction *b) static bool _equalTableSampleClause(const TableSampleClause *a, const TableSampleClause *b) { - COMPARE_SCALAR_FIELD(tsmhandler); + COMPARE_OID_FIELD(tsmhandler); COMPARE_NODE_FIELD(args); COMPARE_NODE_FIELD(repeatable); @@ -2735,11 +2745,11 @@ _equalTableSampleClause(const TableSampleClause *a, const TableSampleClause *b) static bool _equalWithCheckOption(const WithCheckOption *a, const WithCheckOption *b) { - COMPARE_SCALAR_FIELD(kind); + COMPARE_ENUM_FIELD(kind, WCOKind); COMPARE_STRING_FIELD(relname); COMPARE_STRING_FIELD(polname); COMPARE_NODE_FIELD(qual); - COMPARE_SCALAR_FIELD(cascaded); + COMPARE_BOOL_FIELD(cascaded); return true; } @@ -2747,11 +2757,11 @@ _equalWithCheckOption(const WithCheckOption *a, const WithCheckOption *b) static bool _equalSortGroupClause(const SortGroupClause *a, const SortGroupClause *b) { - COMPARE_SCALAR_FIELD(tleSortGroupRef); - COMPARE_SCALAR_FIELD(eqop); - COMPARE_SCALAR_FIELD(sortop); - COMPARE_SCALAR_FIELD(nulls_first); - COMPARE_SCALAR_FIELD(hashable); + COMPARE_UINT_FIELD(tleSortGroupRef); + COMPARE_OID_FIELD(eqop); + COMPARE_OID_FIELD(sortop); + COMPARE_BOOL_FIELD(nulls_first); + COMPARE_BOOL_FIELD(hashable); return true; } @@ -2759,7 +2769,7 @@ _equalSortGroupClause(const SortGroupClause *a, const SortGroupClause *b) static bool _equalGroupingSet(const GroupingSet *a, const GroupingSet *b) { - COMPARE_SCALAR_FIELD(kind); + COMPARE_ENUM_FIELD(kind, GroupingSetKind); COMPARE_NODE_FIELD(content); COMPARE_LOCATION_FIELD(location); @@ -2773,16 +2783,16 @@ _equalWindowClause(const WindowClause *a, const WindowClause *b) COMPARE_STRING_FIELD(refname); COMPARE_NODE_FIELD(partitionClause); COMPARE_NODE_FIELD(orderClause); - COMPARE_SCALAR_FIELD(frameOptions); + COMPARE_INT_FIELD(frameOptions); COMPARE_NODE_FIELD(startOffset); COMPARE_NODE_FIELD(endOffset); - COMPARE_SCALAR_FIELD(startInRangeFunc); - COMPARE_SCALAR_FIELD(endInRangeFunc); - COMPARE_SCALAR_FIELD(inRangeColl); - COMPARE_SCALAR_FIELD(inRangeAsc); - COMPARE_SCALAR_FIELD(inRangeNullsFirst); - COMPARE_SCALAR_FIELD(winref); - COMPARE_SCALAR_FIELD(copiedOrder); + COMPARE_OID_FIELD(startInRangeFunc); + COMPARE_OID_FIELD(endInRangeFunc); + COMPARE_OID_FIELD(inRangeColl); + COMPARE_BOOL_FIELD(inRangeAsc); + COMPARE_BOOL_FIELD(inRangeNullsFirst); + COMPARE_UINT_FIELD(winref); + COMPARE_BOOL_FIELD(copiedOrder); return true; } @@ -2790,10 +2800,10 @@ _equalWindowClause(const WindowClause *a, const WindowClause *b) static bool _equalRowMarkClause(const RowMarkClause *a, const RowMarkClause *b) { - COMPARE_SCALAR_FIELD(rti); - COMPARE_SCALAR_FIELD(strength); - COMPARE_SCALAR_FIELD(waitPolicy); - COMPARE_SCALAR_FIELD(pushedDown); + COMPARE_UINT_FIELD(rti); + COMPARE_ENUM_FIELD(strength, LockClauseStrength); + COMPARE_ENUM_FIELD(waitPolicy, LockWaitPolicy); + COMPARE_BOOL_FIELD(pushedDown); return true; } @@ -2802,7 +2812,7 @@ static bool _equalWithClause(const WithClause *a, const WithClause *b) { COMPARE_NODE_FIELD(ctes); - COMPARE_SCALAR_FIELD(recursive); + COMPARE_BOOL_FIELD(recursive); COMPARE_LOCATION_FIELD(location); return true; @@ -2822,7 +2832,7 @@ _equalInferClause(const InferClause *a, const InferClause *b) static bool _equalOnConflictClause(const OnConflictClause *a, const OnConflictClause *b) { - COMPARE_SCALAR_FIELD(action); + COMPARE_ENUM_FIELD(action, OnConflictAction); COMPARE_NODE_FIELD(infer); COMPARE_NODE_FIELD(targetList); COMPARE_NODE_FIELD(whereClause); @@ -2836,11 +2846,11 @@ _equalCommonTableExpr(const CommonTableExpr *a, const CommonTableExpr *b) { COMPARE_STRING_FIELD(ctename); COMPARE_NODE_FIELD(aliascolnames); - COMPARE_SCALAR_FIELD(ctematerialized); + COMPARE_ENUM_FIELD(ctematerialized, CTEMaterialize); COMPARE_NODE_FIELD(ctequery); COMPARE_LOCATION_FIELD(location); - COMPARE_SCALAR_FIELD(cterecursive); - COMPARE_SCALAR_FIELD(cterefcount); + COMPARE_BOOL_FIELD(cterecursive); + COMPARE_INT_FIELD(cterefcount); COMPARE_NODE_FIELD(ctecolnames); COMPARE_NODE_FIELD(ctecoltypes); COMPARE_NODE_FIELD(ctecoltypmods); @@ -2852,7 +2862,7 @@ _equalCommonTableExpr(const CommonTableExpr *a, const CommonTableExpr *b) static bool _equalXmlSerialize(const XmlSerialize *a, const XmlSerialize *b) { - COMPARE_SCALAR_FIELD(xmloption); + COMPARE_ENUM_FIELD(xmloption, XmlOptionType); COMPARE_NODE_FIELD(expr); COMPARE_NODE_FIELD(typeName); COMPARE_LOCATION_FIELD(location); @@ -2863,7 +2873,7 @@ _equalXmlSerialize(const XmlSerialize *a, const XmlSerialize *b) static bool _equalRoleSpec(const RoleSpec *a, const RoleSpec *b) { - COMPARE_SCALAR_FIELD(roletype); + COMPARE_ENUM_FIELD(roletype, RoleSpecType); COMPARE_STRING_FIELD(rolename); COMPARE_LOCATION_FIELD(location); @@ -2874,8 +2884,8 @@ static bool _equalTriggerTransition(const TriggerTransition *a, const TriggerTransition *b) { COMPARE_STRING_FIELD(name); - COMPARE_SCALAR_FIELD(isNew); - COMPARE_SCALAR_FIELD(isTable); + COMPARE_BOOL_FIELD(isNew); + COMPARE_BOOL_FIELD(isTable); return true; } @@ -2905,10 +2915,10 @@ _equalPartitionSpec(const PartitionSpec *a, const PartitionSpec *b) static bool _equalPartitionBoundSpec(const PartitionBoundSpec *a, const PartitionBoundSpec *b) { - COMPARE_SCALAR_FIELD(strategy); - COMPARE_SCALAR_FIELD(is_default); - COMPARE_SCALAR_FIELD(modulus); - COMPARE_SCALAR_FIELD(remainder); + COMPARE_CHAR_FIELD(strategy); + COMPARE_BOOL_FIELD(is_default); + COMPARE_INT_FIELD(modulus); + COMPARE_INT_FIELD(remainder); COMPARE_NODE_FIELD(listdatums); COMPARE_NODE_FIELD(lowerdatums); COMPARE_NODE_FIELD(upperdatums); @@ -2920,7 +2930,7 @@ _equalPartitionBoundSpec(const PartitionBoundSpec *a, const PartitionBoundSpec * static bool _equalPartitionRangeDatum(const PartitionRangeDatum *a, const PartitionRangeDatum *b) { - COMPARE_SCALAR_FIELD(kind); + COMPARE_ENUM_FIELD(kind, PartitionRangeDatumKind); COMPARE_NODE_FIELD(value); COMPARE_LOCATION_FIELD(location); @@ -2950,8 +2960,8 @@ _equalList(const List *a, const List *b) * Try to reject by simple scalar checks before grovelling through all the * list elements... */ - COMPARE_SCALAR_FIELD(type); - COMPARE_SCALAR_FIELD(length); + COMPARE_ENUM_FIELD(type, NodeTag); + COMPARE_INT_FIELD(length); /* * We place the switch outside the loop for the sake of efficiency; this @@ -3002,12 +3012,12 @@ _equalList(const List *a, const List *b) static bool _equalValue(const Value *a, const Value *b) { - COMPARE_SCALAR_FIELD(type); + COMPARE_ENUM_FIELD(type, NodeTag); switch (a->type) { case T_Integer: - COMPARE_SCALAR_FIELD(val.ival); + COMPARE_INT_FIELD(val.ival); break; case T_Float: case T_String: -- 2.17.1