Clean up two rather nasty bugs in operator selection code.

1. If there is exactly one pg_operator entry of the right name and oprkind,
oper() and related routines would return that entry whether its input type
had anything to do with the request or not.  This is just premature
optimization: we shouldn't return the single candidate until after we verify
that it really is a valid candidate, ie, is at least coercion-compatible
with the given types.

2. oper() and related routines only promise a coercion-compatible result.
Unfortunately, there were quite a few callers that assumed the returned
operator is binary-compatible with the given datatype; they would proceed
to call it without making any datatype coercions.  These callers include
sorting, grouping, aggregation, and VACUUM ANALYZE.  In general I think
it is appropriate for these callers to require an exact or binary-compatible
match, so I've added a new routine compatible_oper() that only succeeds if
it can find an operator that doesn't require any run-time conversions.
Callers now call oper() or compatible_oper() depending on whether they are
prepared to deal with type conversion or not.

The upshot of these bugs is revealed by the following silliness in PL/Tcl's
selftest: it creates an operator @< on int4, and then tries to use it to
sort a char(N) column.  The system would let it do that :-( (and evidently
has done so since 6.3 :-( :-().  The result in this case was just a silly
sort order, but the reverse combination would've provoked coredump from
trying to dereference integers.  With this fix you get more reasonable
behavior:
pltcl_test=# select * from T_pkey1 order by key1, key2 using @<;
ERROR:  Unable to identify an operator '@<' for types 'bpchar' and 'bpchar'
        You will have to retype this query using an explicit cast

Author: tglsfdc

src/backend/commands/analyze.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/analyze.c,v 1.13 2001/01/24 19:42:52 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/analyze.c,v 1.14 2001/02/16 03:16:58 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -152,7 +152,6 @@ analyze_rel(Oid relid, List *anal_cols2, int MESSAGE_LEVEL)
 	for (i = 0; i < attr_cnt; i++)
 	{
 		Operator	func_operator;
-		Form_pg_operator pgopform;
 		VacAttrStats *stats;
 
 		stats = &vacattrstats[i];
@@ -167,21 +166,25 @@ analyze_rel(Oid relid, List *anal_cols2, int MESSAGE_LEVEL)
 		stats->best_cnt = stats->guess1_cnt = stats->guess1_hits = stats->guess2_hits = 0;
 		stats->max_cnt = stats->min_cnt = stats->null_cnt = stats->nonnull_cnt = 0;
 
-		func_operator = oper("=", stats->attr->atttypid, stats->attr->atttypid, true);
+		func_operator = compatible_oper("=",
+										stats->attr->atttypid,
+										stats->attr->atttypid,
+										true);
 		if (func_operator != NULL)
 		{
-			pgopform = (Form_pg_operator) GETSTRUCT(func_operator);
-			fmgr_info(pgopform->oprcode, &(stats->f_cmpeq));
+			fmgr_info(oprfuncid(func_operator), &(stats->f_cmpeq));
 			ReleaseSysCache(func_operator);
 		}
 		else
 			stats->f_cmpeq.fn_addr = NULL;
 
-		func_operator = oper("<", stats->attr->atttypid, stats->attr->atttypid, true);
+		func_operator = compatible_oper("<",
+										stats->attr->atttypid,
+										stats->attr->atttypid,
+										true);
 		if (func_operator != NULL)
 		{
-			pgopform = (Form_pg_operator) GETSTRUCT(func_operator);
-			fmgr_info(pgopform->oprcode, &(stats->f_cmplt));
+			fmgr_info(oprfuncid(func_operator), &(stats->f_cmplt));
 			stats->op_cmplt = oprid(func_operator);
 			ReleaseSysCache(func_operator);
 		}
@@ -191,11 +194,13 @@ analyze_rel(Oid relid, List *anal_cols2, int MESSAGE_LEVEL)
 			stats->op_cmplt = InvalidOid;
 		}
 
-		func_operator = oper(">", stats->attr->atttypid, stats->attr->atttypid, true);
+		func_operator = compatible_oper(">",
+										stats->attr->atttypid,
+										stats->attr->atttypid,
+										true);
 		if (func_operator != NULL)
 		{
-			pgopform = (Form_pg_operator) GETSTRUCT(func_operator);
-			fmgr_info(pgopform->oprcode, &(stats->f_cmpgt));
+			fmgr_info(oprfuncid(func_operator), &(stats->f_cmpgt));
 			ReleaseSysCache(func_operator);
 		}
 		else

src/backend/executor/nodeAgg.c

@@ -46,7 +46,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/nodeAgg.c,v 1.74 2001/02/15 21:47:08 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/nodeAgg.c,v 1.75 2001/02/16 03:16:57 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -909,21 +909,19 @@ ExecInitAgg(Agg *node, EState *estate, Plan *parent)
 			 * (Consider COUNT(*).)
 			 */
 			Oid			inputType = exprType(aggref->target);
-			Operator	eq_operator;
-			Form_pg_operator pgopform;
+			Oid			eq_function;
 
 			peraggstate->inputType = inputType;
 			get_typlenbyval(inputType,
 							&peraggstate->inputtypeLen,
 							&peraggstate->inputtypeByVal);
 
-			eq_operator = oper("=", inputType, inputType, true);
-			if (!HeapTupleIsValid(eq_operator))
+			eq_function = compatible_oper_funcid("=", inputType, inputType,
+												 true);
+			if (!OidIsValid(eq_function))
 				elog(ERROR, "Unable to identify an equality operator for type '%s'",
 					 typeidTypeName(inputType));
-			pgopform = (Form_pg_operator) GETSTRUCT(eq_operator);
-			fmgr_info(pgopform->oprcode, &(peraggstate->equalfn));
-			ReleaseSysCache(eq_operator);
+			fmgr_info(eq_function, &(peraggstate->equalfn));
 			peraggstate->sortOperator = any_ordering_op(inputType);
 			peraggstate->sortstate = NULL;
 		}

src/backend/executor/nodeGroup.c

@@ -15,7 +15,7 @@
  *	  locate group boundaries.
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/nodeGroup.c,v 1.40 2001/01/24 19:42:54 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/nodeGroup.c,v 1.41 2001/02/16 03:16:57 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -495,16 +495,13 @@ execTuplesMatchPrepare(TupleDesc tupdesc,
 	{
 		AttrNumber	att = matchColIdx[i];
 		Oid			typid = tupdesc->attrs[att - 1]->atttypid;
-		Operator	eq_operator;
-		Form_pg_operator pgopform;
+		Oid			eq_function;
 
-		eq_operator = oper("=", typid, typid, true);
-		if (!HeapTupleIsValid(eq_operator))
+		eq_function = compatible_oper_funcid("=", typid, typid, true);
+		if (!OidIsValid(eq_function))
 			elog(ERROR, "Unable to identify an equality operator for type '%s'",
 				 typeidTypeName(typid));
-		pgopform = (Form_pg_operator) GETSTRUCT(eq_operator);
-		fmgr_info(pgopform->oprcode, &eqfunctions[i]);
-		ReleaseSysCache(eq_operator);
+		fmgr_info(eq_function, &eqfunctions[i]);
 	}
 
 	return eqfunctions;

src/backend/optimizer/path/indxpath.c

@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.101 2001/01/24 19:42:57 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.102 2001/02/16 03:16:57 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -878,7 +878,7 @@ indexable_operator(Expr *clause, Oid opclass, Oid relam,
 	 * (In theory this might find a non-semantically-comparable operator,
 	 * but in practice that seems pretty unlikely for binary-compatible types.)
 	 */
-	new_op = oper_oid(opname, indexkeytype, indexkeytype, true);
+	new_op = compatible_oper_opid(opname, indexkeytype, indexkeytype, true);
 
 	if (OidIsValid(new_op))
 	{

src/backend/optimizer/plan/initsplan.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/plan/initsplan.c,v 1.56 2001/01/24 19:42:58 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/plan/initsplan.c,v 1.57 2001/02/16 03:16:57 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -617,7 +617,7 @@ process_implied_equality(Query *root, Node *item1, Node *item2,
 	 */
 	ltype = exprType(item1);
 	rtype = exprType(item2);
-	eq_operator = oper("=", ltype, rtype, true);
+	eq_operator = compatible_oper("=", ltype, rtype, true);
 	if (!HeapTupleIsValid(eq_operator))
 	{
 		/*

src/backend/parser/parse_clause.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.76 2001/02/14 21:35:03 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.77 2001/02/16 03:16:57 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -1155,10 +1155,10 @@ addTargetToSortList(TargetEntry *tle, List *sortlist, List *targetlist,
 		sortcl->tleSortGroupRef = assignSortGroupRef(tle, targetlist);
 
 		if (opname)
-			sortcl->sortop = oper_oid(opname,
-									  tle->resdom->restype,
-									  tle->resdom->restype,
-									  false);
+			sortcl->sortop = compatible_oper_opid(opname,
+												  tle->resdom->restype,
+												  tle->resdom->restype,
+												  false);
 		else
 			sortcl->sortop = any_ordering_op(tle->resdom->restype);
 

src/backend/parser/parse_expr.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.90 2001/02/14 21:35:04 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.91 2001/02/16 03:16:58 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -383,6 +383,11 @@ transformExpr(ParseState *pstate, Node *expr, int precedence)
 						lexpr = lfirst(left_list);
 						left_list = lnext(left_list);
 
+						/*
+						 * It's OK to use oper() not compatible_oper() here,
+						 * because make_subplan() will insert type coercion
+						 * calls if needed.
+						 */
 						optup = oper(op,
 									 exprType(lexpr),
 									 exprType(tent->expr),