summaryrefslogtreecommitdiff
path: root/src/backend/optimizer
diff options
context:
space:
mode:
Diffstat (limited to 'src/backend/optimizer')
-rw-r--r--src/backend/optimizer/path/allpaths.c28
-rw-r--r--src/backend/optimizer/path/equivclass.c3
-rw-r--r--src/backend/optimizer/path/pathkeys.c22
-rw-r--r--src/backend/optimizer/plan/createplan.c10
-rw-r--r--src/backend/optimizer/util/plancat.c38
-rw-r--r--src/backend/optimizer/util/predtest.c122
6 files changed, 108 insertions, 115 deletions
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index df3453f99f0..905250b3325 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -2313,16 +2313,15 @@ find_window_run_conditions(Query *subquery, RangeTblEntry *rte, Index rti,
runopexpr = NULL;
runoperator = InvalidOid;
- opinfos = get_op_btree_interpretation(opexpr->opno);
+ opinfos = get_op_index_interpretation(opexpr->opno);
foreach(lc, opinfos)
{
- OpBtreeInterpretation *opinfo = (OpBtreeInterpretation *) lfirst(lc);
- int strategy = opinfo->strategy;
+ OpIndexInterpretation *opinfo = (OpIndexInterpretation *) lfirst(lc);
+ CompareType cmptype = opinfo->cmptype;
/* handle < / <= */
- if (strategy == BTLessStrategyNumber ||
- strategy == BTLessEqualStrategyNumber)
+ if (cmptype == COMPARE_LT || cmptype == COMPARE_LE)
{
/*
* < / <= is supported for monotonically increasing functions in
@@ -2339,8 +2338,7 @@ find_window_run_conditions(Query *subquery, RangeTblEntry *rte, Index rti,
break;
}
/* handle > / >= */
- else if (strategy == BTGreaterStrategyNumber ||
- strategy == BTGreaterEqualStrategyNumber)
+ else if (cmptype == COMPARE_GT || cmptype == COMPARE_GE)
{
/*
* > / >= is supported for monotonically decreasing functions in
@@ -2357,9 +2355,9 @@ find_window_run_conditions(Query *subquery, RangeTblEntry *rte, Index rti,
break;
}
/* handle = */
- else if (strategy == BTEqualStrategyNumber)
+ else if (cmptype == COMPARE_EQ)
{
- int16 newstrategy;
+ CompareType newcmptype;
/*
* When both monotonically increasing and decreasing then the
@@ -2383,19 +2381,19 @@ find_window_run_conditions(Query *subquery, RangeTblEntry *rte, Index rti,
* below the value in the equality condition.
*/
if (res->monotonic & MONOTONICFUNC_INCREASING)
- newstrategy = wfunc_left ? BTLessEqualStrategyNumber : BTGreaterEqualStrategyNumber;
+ newcmptype = wfunc_left ? COMPARE_LE : COMPARE_GE;
else
- newstrategy = wfunc_left ? BTGreaterEqualStrategyNumber : BTLessEqualStrategyNumber;
+ newcmptype = wfunc_left ? COMPARE_GE : COMPARE_LE;
/* We must keep the original equality qual */
*keep_original = true;
runopexpr = opexpr;
/* determine the operator to use for the WindowFuncRunCondition */
- runoperator = get_opfamily_member(opinfo->opfamily_id,
- opinfo->oplefttype,
- opinfo->oprighttype,
- newstrategy);
+ runoperator = get_opfamily_member_for_cmptype(opinfo->opfamily_id,
+ opinfo->oplefttype,
+ opinfo->oprighttype,
+ newcmptype);
break;
}
}
diff --git a/src/backend/optimizer/path/equivclass.c b/src/backend/optimizer/path/equivclass.c
index 9cd54c573a8..5fb2cf0daf8 100644
--- a/src/backend/optimizer/path/equivclass.c
+++ b/src/backend/optimizer/path/equivclass.c
@@ -1845,8 +1845,7 @@ select_equality_operator(EquivalenceClass *ec, Oid lefttype, Oid righttype)
Oid opfamily = lfirst_oid(lc);
Oid opno;
- opno = get_opfamily_member(opfamily, lefttype, righttype,
- BTEqualStrategyNumber);
+ opno = get_opfamily_member_for_cmptype(opfamily, lefttype, righttype, COMPARE_EQ);
if (!OidIsValid(opno))
continue;
/* If no barrier quals in query, don't worry about leaky operators */
diff --git a/src/backend/optimizer/path/pathkeys.c b/src/backend/optimizer/path/pathkeys.c
index 6fac08cb0d9..981802d7b9d 100644
--- a/src/backend/optimizer/path/pathkeys.c
+++ b/src/backend/optimizer/path/pathkeys.c
@@ -219,13 +219,13 @@ make_pathkey_from_sortinfo(PlannerInfo *root,
* more than one opfamily. So we have to look up the opfamily's equality
* operator and get its membership.
*/
- equality_op = get_opfamily_member(opfamily,
- opcintype,
- opcintype,
- BTEqualStrategyNumber);
+ equality_op = get_opfamily_member_for_cmptype(opfamily,
+ opcintype,
+ opcintype,
+ COMPARE_EQ);
if (!OidIsValid(equality_op)) /* shouldn't happen */
elog(ERROR, "missing operator %d(%u,%u) in opfamily %u",
- BTEqualStrategyNumber, opcintype, opcintype, opfamily);
+ COMPARE_EQ, opcintype, opcintype, opfamily);
opfamilies = get_mergejoin_opfamilies(equality_op);
if (!opfamilies) /* certainly should find some */
elog(ERROR, "could not find opfamilies for equality operator %u",
@@ -264,11 +264,11 @@ make_pathkey_from_sortop(PlannerInfo *root,
Oid opfamily,
opcintype,
collation;
- int16 strategy;
+ CompareType cmptype;
/* Find the operator in pg_amop --- failure shouldn't happen */
if (!get_ordering_op_properties(ordering_op,
- &opfamily, &opcintype, &strategy))
+ &opfamily, &opcintype, &cmptype))
elog(ERROR, "operator %u is not a valid ordering operator",
ordering_op);
@@ -1006,12 +1006,12 @@ build_expression_pathkey(PlannerInfo *root,
List *pathkeys;
Oid opfamily,
opcintype;
- int16 strategy;
+ CompareType cmptype;
PathKey *cpathkey;
/* Find the operator in pg_amop --- failure shouldn't happen */
if (!get_ordering_op_properties(opno,
- &opfamily, &opcintype, &strategy))
+ &opfamily, &opcintype, &cmptype))
elog(ERROR, "operator %u is not a valid ordering operator",
opno);
@@ -1020,8 +1020,8 @@ build_expression_pathkey(PlannerInfo *root,
opfamily,
opcintype,
exprCollation((Node *) expr),
- (strategy == BTGreaterStrategyNumber),
- (strategy == BTGreaterStrategyNumber),
+ (cmptype == COMPARE_GT),
+ (cmptype == COMPARE_GT),
0,
rel,
create_it);
diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index 359db4ba9dd..a8f22a8c154 100644
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -6893,13 +6893,13 @@ make_unique_from_pathkeys(Plan *lefttree, List *pathkeys, int numCols)
* Look up the correct equality operator from the PathKey's slightly
* abstracted representation.
*/
- eqop = get_opfamily_member(pathkey->pk_opfamily,
- pk_datatype,
- pk_datatype,
- BTEqualStrategyNumber);
+ eqop = get_opfamily_member_for_cmptype(pathkey->pk_opfamily,
+ pk_datatype,
+ pk_datatype,
+ COMPARE_EQ);
if (!OidIsValid(eqop)) /* should not happen */
elog(ERROR, "missing operator %d(%u,%u) in opfamily %u",
- BTEqualStrategyNumber, pk_datatype, pk_datatype,
+ COMPARE_EQ, pk_datatype, pk_datatype,
pathkey->pk_opfamily);
uniqColIdx[keyno] = tle->resno;
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 441684a72b1..67d879be8b8 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -365,14 +365,10 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
* Since "<" uniquely defines the behavior of a sort
* order, this is a sufficient test.
*
- * XXX This method is rather slow and also requires the
- * undesirable assumption that the other index AM numbers
- * its strategies the same as btree. It'd be better to
- * have a way to explicitly declare the corresponding
- * btree opfamily for each opfamily of the other index
- * type. But given the lack of current or foreseeable
- * amcanorder index types, it's not worth expending more
- * effort on now.
+ * XXX This method is rather slow and complicated. It'd
+ * be better to have a way to explicitly declare the
+ * corresponding btree opfamily for each opfamily of the
+ * other index type.
*/
info->sortopfamily = (Oid *) palloc(sizeof(Oid) * nkeycolumns);
info->reverse_sort = (bool *) palloc(sizeof(bool) * nkeycolumns);
@@ -382,27 +378,27 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
{
int16 opt = indexRelation->rd_indoption[i];
Oid ltopr;
- Oid btopfamily;
- Oid btopcintype;
- int16 btstrategy;
+ Oid opfamily;
+ Oid opcintype;
+ CompareType cmptype;
info->reverse_sort[i] = (opt & INDOPTION_DESC) != 0;
info->nulls_first[i] = (opt & INDOPTION_NULLS_FIRST) != 0;
- ltopr = get_opfamily_member(info->opfamily[i],
- info->opcintype[i],
- info->opcintype[i],
- BTLessStrategyNumber);
+ ltopr = get_opfamily_member_for_cmptype(info->opfamily[i],
+ info->opcintype[i],
+ info->opcintype[i],
+ COMPARE_LT);
if (OidIsValid(ltopr) &&
get_ordering_op_properties(ltopr,
- &btopfamily,
- &btopcintype,
- &btstrategy) &&
- btopcintype == info->opcintype[i] &&
- btstrategy == BTLessStrategyNumber)
+ &opfamily,
+ &opcintype,
+ &cmptype) &&
+ opcintype == info->opcintype[i] &&
+ cmptype == COMPARE_LT)
{
/* Successful mapping */
- info->sortopfamily[i] = btopfamily;
+ info->sortopfamily[i] = opfamily;
}
else
{
diff --git a/src/backend/optimizer/util/predtest.c b/src/backend/optimizer/util/predtest.c
index b76fc81b08d..ac28573cd0a 100644
--- a/src/backend/optimizer/util/predtest.c
+++ b/src/backend/optimizer/util/predtest.c
@@ -1605,36 +1605,36 @@ clause_is_strict_for(Node *clause, Node *subexpr, bool allow_false)
/*
- * Define "operator implication tables" for btree operators ("strategies"),
+ * Define "operator implication tables" for index operators ("cmptypes"),
* and similar tables for refutation.
*
- * The strategy numbers defined by btree indexes (see access/stratnum.h) are:
- * 1 < 2 <= 3 = 4 >= 5 >
+ * The row compare numbers defined by indexes (see access/cmptype.h) are:
+ * 1 < 2 <= 3 = 4 >= 5 > 6 <>
* and in addition we use 6 to represent <>. <> is not a btree-indexable
* operator, but we assume here that if an equality operator of a btree
* opfamily has a negator operator, the negator behaves as <> for the opfamily.
- * (This convention is also known to get_op_btree_interpretation().)
+ * (This convention is also known to get_op_index_interpretation().)
*
- * BT_implies_table[] and BT_refutes_table[] are used for cases where we have
+ * RC_implies_table[] and RC_refutes_table[] are used for cases where we have
* two identical subexpressions and we want to know whether one operator
* expression implies or refutes the other. That is, if the "clause" is
* EXPR1 clause_op EXPR2 and the "predicate" is EXPR1 pred_op EXPR2 for the
* same two (immutable) subexpressions:
- * BT_implies_table[clause_op-1][pred_op-1]
+ * RC_implies_table[clause_op-1][pred_op-1]
* is true if the clause implies the predicate
- * BT_refutes_table[clause_op-1][pred_op-1]
+ * RC_refutes_table[clause_op-1][pred_op-1]
* is true if the clause refutes the predicate
- * where clause_op and pred_op are strategy numbers (from 1 to 6) in the
- * same btree opfamily. For example, "x < y" implies "x <= y" and refutes
+ * where clause_op and pred_op are cmptype numbers (from 1 to 6) in the
+ * same opfamily. For example, "x < y" implies "x <= y" and refutes
* "x > y".
*
- * BT_implic_table[] and BT_refute_table[] are used where we have two
+ * RC_implic_table[] and RC_refute_table[] are used where we have two
* constants that we need to compare. The interpretation of:
*
- * test_op = BT_implic_table[clause_op-1][pred_op-1]
+ * test_op = RC_implic_table[clause_op-1][pred_op-1]
*
- * where test_op, clause_op and pred_op are strategy numbers (from 1 to 6)
- * of btree operators, is as follows:
+ * where test_op, clause_op and pred_op are cmptypes (from 1 to 6)
+ * of index operators, is as follows:
*
* If you know, for some EXPR, that "EXPR clause_op CONST1" is true, and you
* want to determine whether "EXPR pred_op CONST2" must also be true, then
@@ -1645,7 +1645,7 @@ clause_is_strict_for(Node *clause, Node *subexpr, bool allow_false)
* For example, if clause is "Quantity > 10" and pred is "Quantity > 5"
* then we test "5 <= 10" which evals to true, so clause implies pred.
*
- * Similarly, the interpretation of a BT_refute_table entry is:
+ * Similarly, the interpretation of a RC_refute_table entry is:
*
* If you know, for some EXPR, that "EXPR clause_op CONST1" is true, and you
* want to determine whether "EXPR pred_op CONST2" must be false, then
@@ -1659,17 +1659,17 @@ clause_is_strict_for(Node *clause, Node *subexpr, bool allow_false)
* An entry where test_op == 0 means the implication cannot be determined.
*/
-#define BTLT BTLessStrategyNumber
-#define BTLE BTLessEqualStrategyNumber
-#define BTEQ BTEqualStrategyNumber
-#define BTGE BTGreaterEqualStrategyNumber
-#define BTGT BTGreaterStrategyNumber
-#define BTNE COMPARE_NE
+#define RCLT COMPARE_LT
+#define RCLE COMPARE_LE
+#define RCEQ COMPARE_EQ
+#define RCGE COMPARE_GE
+#define RCGT COMPARE_GT
+#define RCNE COMPARE_NE
/* We use "none" for 0/false to make the tables align nicely */
#define none 0
-static const bool BT_implies_table[6][6] = {
+static const bool RC_implies_table[6][6] = {
/*
* The predicate operator:
* LT LE EQ GE GT NE
@@ -1682,7 +1682,7 @@ static const bool BT_implies_table[6][6] = {
{none, none, none, none, none, true} /* NE */
};
-static const bool BT_refutes_table[6][6] = {
+static const bool RC_refutes_table[6][6] = {
/*
* The predicate operator:
* LT LE EQ GE GT NE
@@ -1695,30 +1695,30 @@ static const bool BT_refutes_table[6][6] = {
{none, none, true, none, none, none} /* NE */
};
-static const StrategyNumber BT_implic_table[6][6] = {
+static const CompareType RC_implic_table[6][6] = {
/*
* The predicate operator:
* LT LE EQ GE GT NE
*/
- {BTGE, BTGE, none, none, none, BTGE}, /* LT */
- {BTGT, BTGE, none, none, none, BTGT}, /* LE */
- {BTGT, BTGE, BTEQ, BTLE, BTLT, BTNE}, /* EQ */
- {none, none, none, BTLE, BTLT, BTLT}, /* GE */
- {none, none, none, BTLE, BTLE, BTLE}, /* GT */
- {none, none, none, none, none, BTEQ} /* NE */
+ {RCGE, RCGE, none, none, none, RCGE}, /* LT */
+ {RCGT, RCGE, none, none, none, RCGT}, /* LE */
+ {RCGT, RCGE, RCEQ, RCLE, RCLT, RCNE}, /* EQ */
+ {none, none, none, RCLE, RCLT, RCLT}, /* GE */
+ {none, none, none, RCLE, RCLE, RCLE}, /* GT */
+ {none, none, none, none, none, RCEQ} /* NE */
};
-static const StrategyNumber BT_refute_table[6][6] = {
+static const CompareType RC_refute_table[6][6] = {
/*
* The predicate operator:
* LT LE EQ GE GT NE
*/
- {none, none, BTGE, BTGE, BTGE, none}, /* LT */
- {none, none, BTGT, BTGT, BTGE, none}, /* LE */
- {BTLE, BTLT, BTNE, BTGT, BTGE, BTEQ}, /* EQ */
- {BTLE, BTLT, BTLT, none, none, none}, /* GE */
- {BTLE, BTLE, BTLE, none, none, none}, /* GT */
- {none, none, BTEQ, none, none, none} /* NE */
+ {none, none, RCGE, RCGE, RCGE, none}, /* LT */
+ {none, none, RCGT, RCGT, RCGE, none}, /* LE */
+ {RCLE, RCLT, RCNE, RCGT, RCGE, RCEQ}, /* EQ */
+ {RCLE, RCLT, RCLT, none, none, none}, /* GE */
+ {RCLE, RCLE, RCLE, none, none, none}, /* GT */
+ {none, none, RCEQ, none, none, none} /* NE */
};
@@ -2165,23 +2165,23 @@ lookup_proof_cache(Oid pred_op, Oid clause_op, bool refute_it)
* operator. This can happen in cases with incomplete sets of cross-type
* comparison operators.
*/
- clause_op_infos = get_op_btree_interpretation(clause_op);
+ clause_op_infos = get_op_index_interpretation(clause_op);
if (clause_op_infos)
- pred_op_infos = get_op_btree_interpretation(pred_op);
+ pred_op_infos = get_op_index_interpretation(pred_op);
else /* no point in looking */
pred_op_infos = NIL;
foreach(lcp, pred_op_infos)
{
- OpBtreeInterpretation *pred_op_info = lfirst(lcp);
+ OpIndexInterpretation *pred_op_info = lfirst(lcp);
Oid opfamily_id = pred_op_info->opfamily_id;
foreach(lcc, clause_op_infos)
{
- OpBtreeInterpretation *clause_op_info = lfirst(lcc);
- StrategyNumber pred_strategy,
- clause_strategy,
- test_strategy;
+ OpIndexInterpretation *clause_op_info = lfirst(lcc);
+ CompareType pred_cmptype,
+ clause_cmptype,
+ test_cmptype;
/* Must find them in same opfamily */
if (opfamily_id != clause_op_info->opfamily_id)
@@ -2189,51 +2189,51 @@ lookup_proof_cache(Oid pred_op, Oid clause_op, bool refute_it)
/* Lefttypes should match */
Assert(clause_op_info->oplefttype == pred_op_info->oplefttype);
- pred_strategy = pred_op_info->strategy;
- clause_strategy = clause_op_info->strategy;
+ pred_cmptype = pred_op_info->cmptype;
+ clause_cmptype = clause_op_info->cmptype;
/*
* Check to see if we can make a proof for same-subexpressions
* cases based on the operators' relationship in this opfamily.
*/
if (refute_it)
- same_subexprs |= BT_refutes_table[clause_strategy - 1][pred_strategy - 1];
+ same_subexprs |= RC_refutes_table[clause_cmptype - 1][pred_cmptype - 1];
else
- same_subexprs |= BT_implies_table[clause_strategy - 1][pred_strategy - 1];
+ same_subexprs |= RC_implies_table[clause_cmptype - 1][pred_cmptype - 1];
/*
- * Look up the "test" strategy number in the implication table
+ * Look up the "test" cmptype number in the implication table
*/
if (refute_it)
- test_strategy = BT_refute_table[clause_strategy - 1][pred_strategy - 1];
+ test_cmptype = RC_refute_table[clause_cmptype - 1][pred_cmptype - 1];
else
- test_strategy = BT_implic_table[clause_strategy - 1][pred_strategy - 1];
+ test_cmptype = RC_implic_table[clause_cmptype - 1][pred_cmptype - 1];
- if (test_strategy == 0)
+ if (test_cmptype == 0)
{
/* Can't determine implication using this interpretation */
continue;
}
/*
- * See if opfamily has an operator for the test strategy and the
+ * See if opfamily has an operator for the test cmptype and the
* datatypes.
*/
- if (test_strategy == BTNE)
+ if (test_cmptype == RCNE)
{
- test_op = get_opfamily_member(opfamily_id,
- pred_op_info->oprighttype,
- clause_op_info->oprighttype,
- BTEqualStrategyNumber);
+ test_op = get_opfamily_member_for_cmptype(opfamily_id,
+ pred_op_info->oprighttype,
+ clause_op_info->oprighttype,
+ COMPARE_EQ);
if (OidIsValid(test_op))
test_op = get_negator(test_op);
}
else
{
- test_op = get_opfamily_member(opfamily_id,
- pred_op_info->oprighttype,
- clause_op_info->oprighttype,
- test_strategy);
+ test_op = get_opfamily_member_for_cmptype(opfamily_id,
+ pred_op_info->oprighttype,
+ clause_op_info->oprighttype,
+ test_cmptype);
}
if (!OidIsValid(test_op))
generated by cgit v1.2.3 (git 2.46.0) at 2025-10-17 13:20:38 +0000