From 9da99d3958cddb86ad98ea88687a13f08a12cf16 Mon Sep 17 00:00:00 2001 From: Peter Eisentraut Date: Wed, 4 Dec 2024 14:03:24 +0100 Subject: [PATCH v19.1 1/2] 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. --- src/backend/executor/execExpr.c | 2 +- src/backend/executor/execExprInterp.c | 12 ++++---- src/backend/executor/nodeIndexscan.c | 4 +-- src/backend/jit/llvm/llvmjit_expr.c | 12 ++++---- src/backend/optimizer/path/indxpath.c | 2 +- src/backend/optimizer/util/predtest.c | 2 +- src/backend/parser/parse_expr.c | 12 ++++---- src/backend/utils/cache/lsyscache.c | 6 ++-- src/include/executor/execExpr.h | 2 +- src/include/nodes/primnodes.h | 41 ++++++++++++++++++--------- src/tools/pgindent/typedefs.list | 2 +- 11 files changed, 55 insertions(+), 42 deletions(-) diff --git a/src/backend/executor/execExpr.c b/src/backend/executor/execExpr.c index e0eb96fd5ad..afa0f6b14a6 100644 --- 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 bad7b195bfb..7ffb611ab8c 100644 --- a/src/backend/executor/execExprInterp.c +++ b/src/backend/executor/execExprInterp.c @@ -1438,22 +1438,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 8000feff4c9..5377ce4ec30 100644 --- 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 c533f552540..88bef871413 100644 --- 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 5d102a0d371..10f4c6a1f19 100644 --- 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 0a132610140..e967d831bf1 100644 --- 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 c2806297aa4..f31e9a4e879 100644 --- 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 a85dc0d891f..af68dce0907 100644 --- 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 56fb0d0adbe..42db1161da1 100644 --- 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 b0ef1952e8f..107eb36a340 100644 --- 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 2d4c870423a..4100e634964 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -455,6 +455,7 @@ CommitTimestampShared CommonEntry CommonTableExpr CompareScalarsContext +CompareType CompiledExprState CompositeIOData CompositeTypeStmt @@ -2487,7 +2488,6 @@ RoleSpecType RoleStmtType RollupData RowCompareExpr -RowCompareType RowExpr RowIdentityVarInfo RowMarkClause base-commit: 7727049e8f663344d4d0457e1d9ec048d626f3d9 -- 2.47.1