Convert from StrategyNumber to CompareType

Reduce the number of places that hardcode a btree strategy number by
instead using comparison types.

Generalize predicate tests beyond btree strategies.  Extend routines
which prove logical implications between predicate expressions to be
usable by more than just B-tree index strategies.

Allow non-btree indexes to participate in mergejoin.  Rather than
hardcoding a requirement that the index be of type btree, just require
that it provide ordering support.

A number of places in the code still had references to btree
strategies where not appropriate, so fix those.  Leave untouched such
strategy numbers in nbtree, spgist, and brin indexes, and also in
table partitioning.  Hardcoded hash and btree references in table
partitioning are part of the design of table partitioning; their
replacement, if even a good idea, is beyond the scope of this patch
series.

Author: Mark Dilger <mark.dilger@enterprisedb.com>
Co-authored-by: Peter Eisentraut <peter@eisentraut.org>
Discussion: https://www.postgresql.org/message-id/flat/E72EAA49-354D-4C2E-8EB9-255197F55330@enterprisedb.com

Author: petere

contrib/postgres_fdw/deparse.c

@@ -3969,17 +3969,17 @@ appendOrderByClause(List *pathkeys, bool has_final_sort,
 			appendStringInfoString(buf, ", ");
 
 		/*
-		 * Lookup the operator corresponding to the strategy in the opclass.
-		 * The datatype used by the opfamily is not necessarily the same as
-		 * the expression type (for array types for example).
+		 * Lookup the operator corresponding to the compare type in the
+		 * opclass. The datatype used by the opfamily is not necessarily the
+		 * same as the expression type (for array types for example).
 		 */
-		oprid = get_opfamily_member(pathkey->pk_opfamily,
-									em->em_datatype,
-									em->em_datatype,
-									pathkey->pk_strategy);
+		oprid = get_opfamily_member_for_cmptype(pathkey->pk_opfamily,
+												em->em_datatype,
+												em->em_datatype,
+												pathkey->pk_cmptype);
 		if (!OidIsValid(oprid))
 			elog(ERROR, "missing operator %d(%u,%u) in opfamily %u",
-				 pathkey->pk_strategy, em->em_datatype, em->em_datatype,
+				 pathkey->pk_cmptype, em->em_datatype, em->em_datatype,
 				 pathkey->pk_opfamily);
 
 		deparseExpr(em_expr, context);

contrib/postgres_fdw/postgres_fdw.c

@@ -999,7 +999,7 @@ get_useful_pathkeys_for_relation(PlannerInfo *root, RelOptInfo *rel)
 		/* Looks like we can generate a pathkey, so let's do it. */
 		pathkey = make_canonical_pathkey(root, cur_ec,
 										 linitial_oid(cur_ec->ec_opfamilies),
-										 BTLessStrategyNumber,
+										 COMPARE_LT,
 										 false);
 		useful_pathkeys_list = lappend(useful_pathkeys_list,
 									   list_make1(pathkey));

src/backend/executor/execExpr.c

@@ -2098,6 +2098,7 @@ ExecInitExprRec(Expr *node, ExprState *state,
 
 					get_op_opfamily_properties(opno, opfamily, false,
 											   &strategy,
+											   NULL,	/* don't need cmptype */
 											   &lefttype,
 											   &righttype);
 					proc = get_opfamily_proc(opfamily,

src/backend/executor/nodeIndexscan.c

@@ -1246,6 +1246,7 @@ ExecIndexBuildScanKeys(PlanState *planstate, Relation index,
 
 			get_op_opfamily_properties(opno, opfamily, isorderby,
 									   &op_strategy,
+									   NULL,	/* don't need cmptype */
 									   &op_lefttype,
 									   &op_righttype);
 
@@ -1364,6 +1365,7 @@ ExecIndexBuildScanKeys(PlanState *planstate, Relation index,
 
 				get_op_opfamily_properties(opno, opfamily, isorderby,
 										   &op_strategy,
+										   NULL,	/* don't need cmptype */
 										   &op_lefttype,
 										   &op_righttype);
 
@@ -1487,6 +1489,7 @@ ExecIndexBuildScanKeys(PlanState *planstate, Relation index,
 
 			get_op_opfamily_properties(opno, opfamily, isorderby,
 									   &op_strategy,
+									   NULL,	/* don't need cmptype */
 									   &op_lefttype,
 									   &op_righttype);
 

src/backend/executor/nodeMergejoin.c

@@ -195,7 +195,7 @@ MJExamineQuals(List *mergeclauses,
 		Oid			collation = mergecollations[iClause];
 		bool		reversed = mergereversals[iClause];
 		bool		nulls_first = mergenullsfirst[iClause];
-		int			op_strategy;
+		CompareType op_cmptype;
 		Oid			op_lefttype;
 		Oid			op_righttype;
 		Oid			sortfunc;
@@ -217,10 +217,11 @@ MJExamineQuals(List *mergeclauses,
 
 		/* Extract the operator's declared left/right datatypes */
 		get_op_opfamily_properties(qual->opno, opfamily, false,
-								   &op_strategy,
+								   NULL,
+								   &op_cmptype,
 								   &op_lefttype,
 								   &op_righttype);
-		if (op_strategy != BTEqualStrategyNumber)	/* should not happen */
+		if (op_cmptype != COMPARE_EQ)	/* should not happen */
 			elog(ERROR, "cannot merge using non-equality operator %u",
 				 qual->opno);
 

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;
 		}
 	}

src/backend/optimizer/path/costsize.c

@@ -3608,7 +3608,7 @@ initial_cost_mergejoin(PlannerInfo *root, JoinCostWorkspace *workspace,
 		/* debugging check */
 		if (opathkey->pk_opfamily != ipathkey->pk_opfamily ||
 			opathkey->pk_eclass->ec_collation != ipathkey->pk_eclass->ec_collation ||
-			opathkey->pk_strategy != ipathkey->pk_strategy ||
+			opathkey->pk_cmptype != ipathkey->pk_cmptype ||
 			opathkey->pk_nulls_first != ipathkey->pk_nulls_first)
 			elog(ERROR, "left and right pathkeys do not match in mergejoin");
 
@@ -4093,7 +4093,7 @@ cached_scansel(PlannerInfo *root, RestrictInfo *rinfo, PathKey *pathkey)
 		cache = (MergeScanSelCache *) lfirst(lc);
 		if (cache->opfamily == pathkey->pk_opfamily &&
 			cache->collation == pathkey->pk_eclass->ec_collation &&
-			cache->strategy == pathkey->pk_strategy &&
+			cache->cmptype == pathkey->pk_cmptype &&
 			cache->nulls_first == pathkey->pk_nulls_first)
 			return cache;
 	}
@@ -4102,7 +4102,7 @@ cached_scansel(PlannerInfo *root, RestrictInfo *rinfo, PathKey *pathkey)
 	mergejoinscansel(root,
 					 (Node *) rinfo->clause,
 					 pathkey->pk_opfamily,
-					 pathkey->pk_strategy,
+					 pathkey->pk_cmptype,
 					 pathkey->pk_nulls_first,
 					 &leftstartsel,
 					 &leftendsel,
@@ -4115,7 +4115,7 @@ cached_scansel(PlannerInfo *root, RestrictInfo *rinfo, PathKey *pathkey)
 	cache = (MergeScanSelCache *) palloc(sizeof(MergeScanSelCache));
 	cache->opfamily = pathkey->pk_opfamily;
 	cache->collation = pathkey->pk_eclass->ec_collation;
-	cache->strategy = pathkey->pk_strategy;
+	cache->cmptype = pathkey->pk_cmptype;
 	cache->nulls_first = pathkey->pk_nulls_first;
 	cache->leftstartsel = leftstartsel;
 	cache->leftendsel = leftendsel;

src/backend/optimizer/path/equivclass.c

@@ -1788,8 +1788,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 */

src/backend/optimizer/path/indxpath.c

@@ -3611,6 +3611,7 @@ expand_indexqual_rowcompare(PlannerInfo *root,
 
 	get_op_opfamily_properties(expr_op, index->opfamily[indexcol], false,
 							   &op_strategy,
+							   NULL,	/* don't need cmptype */
 							   &op_lefttype,
 							   &op_righttype);
 
@@ -3672,6 +3673,7 @@ expand_indexqual_rowcompare(PlannerInfo *root,
 		/* Add operator info to lists */
 		get_op_opfamily_properties(expr_op, index->opfamily[i], false,
 								   &op_strategy,
+								   NULL,	/* don't need cmptype */
 								   &op_lefttype,
 								   &op_righttype);
 		expr_ops = lappend_oid(expr_ops, expr_op);
@@ -3745,6 +3747,10 @@ expand_indexqual_rowcompare(PlannerInfo *root,
 		{
 			RowCompareExpr *rc = makeNode(RowCompareExpr);
 
+			/*
+			 * XXX This assumes that CompareType values match btree strategy
+			 * numbers; see cmptype.h.
+			 */
 			rc->cmptype = (CompareType) op_strategy;
 			rc->opnos = new_ops;
 			rc->opfamilies = list_copy_head(clause->opfamilies,
@@ -3817,8 +3823,7 @@ match_pathkeys_to_index(IndexOptInfo *index, List *pathkeys,
 
 
 		/* Pathkey must request default sort order for the target opfamily */
-		if (pathkey->pk_strategy != BTLessStrategyNumber ||
-			pathkey->pk_nulls_first)
+		if (pathkey->pk_cmptype != COMPARE_LT || pathkey->pk_nulls_first)
 			return;
 
 		/* If eclass is volatile, no hope of using an indexscan */