Rename RowCompareType to CompareType

RowCompareType served as a way to describe the fundamental meaning of
an operator, notionally independent of an operator class (although so
far this was only really supported for btrees).  Its original purpose
was for use inside RowCompareExpr, and it has also found some small
use outside, such as for get_op_btree_interpretation().

We want to expand this now, as a more general way to describe operator
semantics for other index access methods, including gist (to improve
GistTranslateStratnum()) and others not written yet.  To avoid future
confusion, we rename the type to CompareType and the symbols from
ROWCOMPARE_XXX to COMPARE_XXX to reflect their more general purpose.

Reviewed-by: Mark Dilger <[email protected]>
Discussion: https://www.postgresql.org/message-id/flat/E72EAA49-354D-4C2E-8EB9-255197F55330@enterprisedb.com

diff --git a/src/backend/executor/execExpr.c b/src/backend/executor/execExpr.c
index 89514f7a4f00f044679eea24f12ebe6f7bf7ffc1..7a800df8cabfa893c6a0c49041514d63a945a6a6 100644 (file)
--- a/src/backend/executor/execExpr.c
+++ b/src/backend/executor/execExpr.c
@@ -2102,7 +2102,7 @@ ExecInitExprRec(Expr *node, ExprState *state,
 
                /* Finally, examine the last comparison result */
                scratch.opcode = EEOP_ROWCOMPARE_FINAL;
-               scratch.d.rowcompare_final.rctype = rcexpr->rctype;
+               scratch.d.rowcompare_final.cmptype = rcexpr->cmptype;
                ExprEvalPushStep(state, &scratch);
 
                /* adjust jump targets */

diff --git a/src/backend/executor/execExprInterp.c b/src/backend/executor/execExprInterp.c
index b2c00a0a1b171a7cf47dd6f50606b0313438e251..7dfe17b0a86fdbb0135ec0dcc408d4b3e71e6790 100644 (file)
--- a/src/backend/executor/execExprInterp.c
+++ b/src/backend/executor/execExprInterp.c
@@ -1500,22 +1500,22 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
        EEO_CASE(EEOP_ROWCOMPARE_FINAL)
        {
            int32       cmpresult = DatumGetInt32(*op->resvalue);
-           RowCompareType rctype = op->d.rowcompare_final.rctype;
+           CompareType cmptype = op->d.rowcompare_final.cmptype;
 
            *op->resnull = false;
-           switch (rctype)
+           switch (cmptype)
            {
                    /* EQ and NE cases aren't allowed here */
-               case ROWCOMPARE_LT:
+               case COMPARE_LT:
                    *op->resvalue = BoolGetDatum(cmpresult < 0);
                    break;
-               case ROWCOMPARE_LE:
+               case COMPARE_LE:
                    *op->resvalue = BoolGetDatum(cmpresult <= 0);
                    break;
-               case ROWCOMPARE_GE:
+               case COMPARE_GE:
                    *op->resvalue = BoolGetDatum(cmpresult >= 0);
                    break;
-               case ROWCOMPARE_GT:
+               case COMPARE_GT:
                    *op->resvalue = BoolGetDatum(cmpresult > 0);
                    break;
                default:

diff --git a/src/backend/executor/nodeIndexscan.c b/src/backend/executor/nodeIndexscan.c
index 865aba08e8a7437ce5388add0312c43d95b6153a..3b2275e8fe9d4a27dcea7cf868618c5dee7169b8 100644 (file)
--- a/src/backend/executor/nodeIndexscan.c
+++ b/src/backend/executor/nodeIndexscan.c
@@ -1344,7 +1344,7 @@ ExecIndexBuildScanKeys(PlanState *planstate, Relation index,
                                           &op_lefttype,
                                           &op_righttype);
 
-               if (op_strategy != rc->rctype)
+               if (op_strategy != rc->cmptype)
                    elog(ERROR, "RowCompare index qualification contains wrong operator");
 
                opfuncid = get_opfamily_proc(opfamily,
@@ -1421,7 +1421,7 @@ ExecIndexBuildScanKeys(PlanState *planstate, Relation index,
            MemSet(this_scan_key, 0, sizeof(ScanKeyData));
            this_scan_key->sk_flags = SK_ROW_HEADER;
            this_scan_key->sk_attno = first_sub_key->sk_attno;
-           this_scan_key->sk_strategy = rc->rctype;
+           this_scan_key->sk_strategy = rc->cmptype;
            /* sk_subtype, sk_collation, sk_func not used in a header */
            this_scan_key->sk_argument = PointerGetDatum(first_sub_key);
        }

diff --git a/src/backend/jit/llvm/llvmjit_expr.c b/src/backend/jit/llvm/llvmjit_expr.c
index 6c4915e373107dc42cc61b3c33b8e1db2d652608..b0119200ddefe45b5501d0636554de6a98273358 100644 (file)
--- a/src/backend/jit/llvm/llvmjit_expr.c
+++ b/src/backend/jit/llvm/llvmjit_expr.c
@@ -1770,7 +1770,7 @@ llvm_compile_expr(ExprState *state)
 
            case EEOP_ROWCOMPARE_FINAL:
                {
-                   RowCompareType rctype = op->d.rowcompare_final.rctype;
+                   CompareType cmptype = op->d.rowcompare_final.cmptype;
 
                    LLVMValueRef v_cmpresult;
                    LLVMValueRef v_result;
@@ -1786,18 +1786,18 @@ llvm_compile_expr(ExprState *state)
                                       l_load(b, TypeSizeT, v_resvaluep, ""),
                                       LLVMInt32TypeInContext(lc), "");
 
-                   switch (rctype)
+                   switch (cmptype)
                    {
-                       case ROWCOMPARE_LT:
+                       case COMPARE_LT:
                            predicate = LLVMIntSLT;
                            break;
-                       case ROWCOMPARE_LE:
+                       case COMPARE_LE:
                            predicate = LLVMIntSLE;
                            break;
-                       case ROWCOMPARE_GT:
+                       case COMPARE_GT:
                            predicate = LLVMIntSGT;
                            break;
-                       case ROWCOMPARE_GE:
+                       case COMPARE_GE:
                            predicate = LLVMIntSGE;
                            break;
                        default:

diff --git a/src/backend/optimizer/path/indxpath.c b/src/backend/optimizer/path/indxpath.c
index 5f428e835b002f02a4406269197d44e1ff08e207..fa3edf60f3cf14f18cc6cf1a4a1051654e2f02e4 100644 (file)
--- a/src/backend/optimizer/path/indxpath.c
+++ b/src/backend/optimizer/path/indxpath.c
@@ -3675,7 +3675,7 @@ expand_indexqual_rowcompare(PlannerInfo *root,
        {
            RowCompareExpr *rc = makeNode(RowCompareExpr);
 
-           rc->rctype = (RowCompareType) op_strategy;
+           rc->cmptype = (CompareType) op_strategy;
            rc->opnos = new_ops;
            rc->opfamilies = list_copy_head(clause->opfamilies,
                                            matching_cols);

diff --git a/src/backend/optimizer/util/predtest.c b/src/backend/optimizer/util/predtest.c
index 71829aa4f1a5bccfd130308598cd9794a0647411..b76fc81b08d02d18d3a94a1f9ed47c7de334ff5c 100644 (file)
--- a/src/backend/optimizer/util/predtest.c
+++ b/src/backend/optimizer/util/predtest.c
@@ -1664,7 +1664,7 @@ clause_is_strict_for(Node *clause, Node *subexpr, bool allow_false)
 #define BTEQ BTEqualStrategyNumber
 #define BTGE BTGreaterEqualStrategyNumber
 #define BTGT BTGreaterStrategyNumber
-#define BTNE ROWCOMPARE_NE
+#define BTNE COMPARE_NE
 
 /* We use "none" for 0/false to make the tables align nicely */
 #define none 0

diff --git a/src/backend/parser/parse_expr.c b/src/backend/parser/parse_expr.c
index d1f64f8f0a51941fb9180b76456e28ff9aef2526..285a5c88d58a0398e424319335ab9244ca31502c 100644 (file)
--- a/src/backend/parser/parse_expr.c
+++ b/src/backend/parser/parse_expr.c
@@ -2807,7 +2807,7 @@ make_row_comparison_op(ParseState *pstate, List *opname,
                       List *largs, List *rargs, int location)
 {
    RowCompareExpr *rcexpr;
-   RowCompareType rctype;
+   CompareType cmptype;
    List       *opexprs;
    List       *opnos;
    List       *opfamilies;
@@ -2928,15 +2928,15 @@ make_row_comparison_op(ParseState *pstate, List *opname,
                 errhint("Row comparison operators must be associated with btree operator families."),
                 parser_errposition(pstate, location)));
    }
-   rctype = (RowCompareType) i;
+   cmptype = (CompareType) i;
 
    /*
     * For = and <> cases, we just combine the pairwise operators with AND or
     * OR respectively.
     */
-   if (rctype == ROWCOMPARE_EQ)
+   if (cmptype == COMPARE_EQ)
        return (Node *) makeBoolExpr(AND_EXPR, opexprs, location);
-   if (rctype == ROWCOMPARE_NE)
+   if (cmptype == COMPARE_NE)
        return (Node *) makeBoolExpr(OR_EXPR, opexprs, location);
 
    /*
@@ -2953,7 +2953,7 @@ make_row_comparison_op(ParseState *pstate, List *opname,
        {
            OpBtreeInterpretation *opinfo = lfirst(j);
 
-           if (opinfo->strategy == rctype)
+           if (opinfo->strategy == cmptype)
            {
                opfamily = opinfo->opfamily_id;
                break;
@@ -2989,7 +2989,7 @@ make_row_comparison_op(ParseState *pstate, List *opname,
    }
 
    rcexpr = makeNode(RowCompareExpr);
-   rcexpr->rctype = rctype;
+   rcexpr->cmptype = cmptype;
    rcexpr->opnos = opnos;
    rcexpr->opfamilies = opfamilies;
    rcexpr->inputcollids = NIL; /* assign_expr_collations will fix this */

diff --git a/src/backend/utils/cache/lsyscache.c b/src/backend/utils/cache/lsyscache.c
index 8cdb558253668582db1680f46c0280d9b758d534..7a9af03c960c39c51bb736bb01d4bef29cecf1e6 100644 (file)
--- a/src/backend/utils/cache/lsyscache.c
+++ b/src/backend/utils/cache/lsyscache.c
@@ -595,7 +595,7 @@ get_op_hash_functions(Oid opno,
  *
  * In addition to the normal btree operators, we consider a <> operator to be
  * a "member" of an opfamily if its negator is an equality operator of the
- * opfamily.  ROWCOMPARE_NE is returned as the strategy number for this case.
+ * opfamily.  COMPARE_NE is returned as the strategy number for this case.
  */
 List *
 get_op_btree_interpretation(Oid opno)
@@ -666,11 +666,11 @@ get_op_btree_interpretation(Oid opno)
                if (op_strategy != BTEqualStrategyNumber)
                    continue;
 
-               /* OK, report it with "strategy" ROWCOMPARE_NE */
+               /* OK, report it with "strategy" COMPARE_NE */
                thisresult = (OpBtreeInterpretation *)
                    palloc(sizeof(OpBtreeInterpretation));
                thisresult->opfamily_id = op_form->amopfamily;
-               thisresult->strategy = ROWCOMPARE_NE;
+               thisresult->strategy = COMPARE_NE;
                thisresult->oplefttype = op_form->amoplefttype;
                thisresult->oprighttype = op_form->amoprighttype;
                result = lappend(result, thisresult);

diff --git a/src/include/executor/execExpr.h b/src/include/executor/execExpr.h
index 8019e5490e9123681b26794be52e61abd59e12dd..1e42c131781a9c174c6c62190e672c405dcc2eca 100644 (file)
--- a/src/include/executor/execExpr.h
+++ b/src/include/executor/execExpr.h
@@ -494,7 +494,7 @@ typedef struct ExprEvalStep
        /* for EEOP_ROWCOMPARE_FINAL */
        struct
        {
-           RowCompareType rctype;
+           CompareType cmptype;
        }           rowcompare_final;
 
        /* for EEOP_MINMAX */

diff --git a/src/include/nodes/primnodes.h b/src/include/nodes/primnodes.h
index 9c2957eb5464816c5fee479101bd0283130b3bd6..2893dba31c37f5206e9c96c7888f7e805d21920a 100644 (file)
--- a/src/include/nodes/primnodes.h
+++ b/src/include/nodes/primnodes.h
@@ -1435,6 +1435,31 @@ typedef struct RowExpr
    ParseLoc    location;       /* token location, or -1 if unknown */
 } RowExpr;
 
+/*
+ * CompareType - fundamental semantics of certain operators
+ *
+ * These enum symbols represent the fundamental semantics of certain operators
+ * that the system needs to have some hardcoded knowledge about.  (For
+ * example, RowCompareExpr needs to know which operators can be determined to
+ * act like =, <>, <, etc.)  Index access methods map (some of) strategy
+ * numbers to these values so that the system can know about the meaning of
+ * (some of) the operators without needing hardcoded knowledge of index AM's
+ * strategy numbering.
+ *
+ * XXX Currently, this mapping is not fully developed and the values are
+ * chosen to match btree strategy numbers, which is not going to work very
+ * well for other access methods.
+ */
+typedef enum CompareType
+{
+   COMPARE_LT = 1,             /* BTLessStrategyNumber */
+   COMPARE_LE = 2,             /* BTLessEqualStrategyNumber */
+   COMPARE_EQ = 3,             /* BTEqualStrategyNumber */
+   COMPARE_GE = 4,             /* BTGreaterEqualStrategyNumber */
+   COMPARE_GT = 5,             /* BTGreaterStrategyNumber */
+   COMPARE_NE = 6,             /* no such btree strategy */
+} CompareType;
+
 /*
  * RowCompareExpr - row-wise comparison, such as (a, b) <= (1, 2)
  *
@@ -1446,26 +1471,14 @@ typedef struct RowExpr
  *
  * A RowCompareExpr node is only generated for the < <= > >= cases;
  * the = and <> cases are translated to simple AND or OR combinations
- * of the pairwise comparisons.  However, we include = and <> in the
- * RowCompareType enum for the convenience of parser logic.
+ * of the pairwise comparisons.
  */
-typedef enum RowCompareType
-{
-   /* Values of this enum are chosen to match btree strategy numbers */
-   ROWCOMPARE_LT = 1,          /* BTLessStrategyNumber */
-   ROWCOMPARE_LE = 2,          /* BTLessEqualStrategyNumber */
-   ROWCOMPARE_EQ = 3,          /* BTEqualStrategyNumber */
-   ROWCOMPARE_GE = 4,          /* BTGreaterEqualStrategyNumber */
-   ROWCOMPARE_GT = 5,          /* BTGreaterStrategyNumber */
-   ROWCOMPARE_NE = 6,          /* no such btree strategy */
-} RowCompareType;
-
 typedef struct RowCompareExpr
 {
    Expr        xpr;
 
    /* LT LE GE or GT, never EQ or NE */
-   RowCompareType rctype;
+   CompareType cmptype;
    /* OID list of pairwise comparison ops */
    List       *opnos pg_node_attr(query_jumble_ignore);
    /* OID list of containing operator families */

diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 3a392f4ed9a39260e4018870ddbbf392b01bc8fd..94dc956ae8cacd2e9b0731c6152e0a7b67f3c079 100644 (file)
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -458,6 +458,7 @@ CommonEntry
 CommonTableExpr
 CompactAttribute
 CompareScalarsContext
+CompareType
 CompiledExprState
 CompositeIOData
 CompositeTypeStmt
@@ -2494,7 +2495,6 @@ RoleSpecType
 RoleStmtType
 RollupData
 RowCompareExpr
-RowCompareType
 RowExpr
 RowIdentityVarInfo
 RowMarkClause