Remove bogus code in oper_exact --- if it didn't find an exact

match then it tried for a self-commutative operator with the reversed input
data types.  This is pretty silly; there could never be such an operator,
except maybe in binary-compatible-type scenarios, and we have oper_inexact
for that.  Besides which, the oprsanity regress test would complain about
such an operator.  Remove nonfunctional code and simplify routine calling
convention accordingly.

diff --git a/src/backend/parser/parse_node.c b/src/backend/parser/parse_node.c
index 48da11d8d2394fd27a3c1e1514a3eff517ecfc7a..35fa858dc0888931da341c97d3d33af95bac520e 100644 (file)
--- a/src/backend/parser/parse_node.c
+++ b/src/backend/parser/parse_node.c
@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.30 1999/08/22 20:15:04 tgl Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.31 1999/08/23 23:48:39 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -31,10 +31,6 @@
 #include "utils/syscache.h"
 
 static void disallow_setop(char *op, Type optype, Node *operand);
-static Node *make_operand(char *opname,
-                        Node *tree,
-                        Oid orig_typeId,
-                        Oid true_typeId);
 
 /* make_parsestate()
  * Allocate and initialize a new ParseState.
@@ -58,31 +54,31 @@ make_parsestate(ParseState *parentParseState)
 /* make_operand()
  * Ensure argument type match by forcing conversion of constants.
  */
-static Node *
+Node *
 make_operand(char *opname,
                         Node *tree,
                         Oid orig_typeId,
-                        Oid true_typeId)
+                        Oid target_typeId)
 {
        Node       *result;
-       Type            true_type;
+       Type            target_type;
 
        if (tree != NULL)
        {
                result = tree;
-               true_type = typeidType(true_typeId);
-               disallow_setop(opname, true_type, result);
+               target_type = typeidType(target_typeId);
+               disallow_setop(opname, target_type, result);
 
                /* must coerce? */
-               if (true_typeId != orig_typeId)
-                       result = coerce_type(NULL, tree, orig_typeId, true_typeId, -1);
+               if (target_typeId != orig_typeId)
+                       result = coerce_type(NULL, tree, orig_typeId, target_typeId, -1);
        }
        /* otherwise, this is a NULL value */
        else
        {
                Const      *con = makeNode(Const);
 
-               con->consttype = true_typeId;
+               con->consttype = target_typeId;
                con->constlen = 0;
                con->constvalue = (Datum) (struct varlena *) NULL;
                con->constisnull = true;
@@ -128,47 +124,31 @@ make_op(char *opname, Node *ltree, Node *rtree)
                           *right;
        Expr       *result;
 
+       ltypeId = (ltree == NULL) ? UNKNOWNOID : exprType(ltree);
+       rtypeId = (rtree == NULL) ? UNKNOWNOID : exprType(rtree);
+
        /* right operator? */
        if (rtree == NULL)
        {
-               ltypeId = (ltree == NULL) ? UNKNOWNOID : exprType(ltree);
                tup = right_oper(opname, ltypeId);
                opform = (Form_pg_operator) GETSTRUCT(tup);
                left = make_operand(opname, ltree, ltypeId, opform->oprleft);
                right = NULL;
-
        }
 
        /* left operator? */
        else if (ltree == NULL)
        {
-               rtypeId = (rtree == NULL) ? UNKNOWNOID : exprType(rtree);
                tup = left_oper(opname, rtypeId);
                opform = (Form_pg_operator) GETSTRUCT(tup);
                right = make_operand(opname, rtree, rtypeId, opform->oprright);
                left = NULL;
-
        }
 
        /* otherwise, binary operator */
        else
        {
-               /* binary operator */
-               ltypeId = (ltree == NULL) ? UNKNOWNOID : exprType(ltree);
-               rtypeId = (rtree == NULL) ? UNKNOWNOID : exprType(rtree);
-
-               /* check for exact match on this operator... */
-               if (HeapTupleIsValid(tup = oper_exact(opname, ltypeId, rtypeId, &ltree, &rtree, TRUE)))
-               {
-                       ltypeId = exprType(ltree);
-                       rtypeId = exprType(rtree);
-               }
-               /* try to find a match on likely candidates... */
-               else if (!HeapTupleIsValid(tup = oper_inexact(opname, ltypeId, rtypeId, &ltree, &rtree, FALSE)))
-               {
-                       /* Won't return from oper_inexact() without a candidate... */
-               }
-
+               tup = oper(opname, ltypeId, rtypeId, FALSE);
                opform = (Form_pg_operator) GETSTRUCT(tup);
                left = make_operand(opname, ltree, ltypeId, opform->oprleft);
                right = make_operand(opname, rtree, rtypeId, opform->oprright);

diff --git a/src/backend/parser/parse_oper.c b/src/backend/parser/parse_oper.c
index 9a5ab042da68a413237f26164b9b0f7897ef6886..529663b6ce5acae6a00719aadbb44ad0bfe06b95 100644 (file)
--- a/src/backend/parser/parse_oper.c
+++ b/src/backend/parser/parse_oper.c
@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/parser/parse_oper.c,v 1.29 1999/07/17 20:17:25 momjian Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/parser/parse_oper.c,v 1.30 1999/08/23 23:48:39 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -25,6 +25,8 @@
 
 static Oid *oper_select_candidate(int nargs, Oid *input_typeids,
                                          CandidateList candidates);
+static Operator oper_exact(char *op, Oid arg1, Oid arg2);
+static Operator oper_inexact(char *op, Oid arg1, Oid arg2);
 static int binary_oper_get_candidates(char *opname,
                                                   Oid leftTypeId,
                                                   Oid rightTypeId,
@@ -376,15 +378,14 @@ oper_select_candidate(int nargs,
 
 
 /* oper_exact()
- * Given operator, and arguments, return oper struct.
+ * Given operator, and arguments, return oper struct or NULL.
  * Inputs:
  * arg1, arg2: Type IDs
  */
-Operator
-oper_exact(char *op, Oid arg1, Oid arg2, Node **ltree, Node **rtree, bool noWarnings)
+static Operator
+oper_exact(char *op, Oid arg1, Oid arg2)
 {
        HeapTuple       tup;
-       Node       *tree;
 
        /* Unspecified type for one of the arguments? then use the other */
        if ((arg1 == UNKNOWNOID) && (arg2 != InvalidOid))
@@ -398,51 +399,17 @@ oper_exact(char *op, Oid arg1, Oid arg2, Node **ltree, Node **rtree, bool noWarn
                                                          ObjectIdGetDatum(arg2),
                                                          CharGetDatum('b'));
 
-       /*
-        * Did not find anything? then try flipping arguments on a commutative
-        * operator...
-        */
-       if (!HeapTupleIsValid(tup) && (arg1 != arg2))
-       {
-               tup = SearchSysCacheTuple(OPRNAME,
-                                                                 PointerGetDatum(op),
-                                                                 ObjectIdGetDatum(arg2),
-                                                                 ObjectIdGetDatum(arg1),
-                                                                 CharGetDatum('b'));
-
-               if (HeapTupleIsValid(tup))
-               {
-                       Form_pg_operator opform;
-
-                       opform = (Form_pg_operator) GETSTRUCT(tup);
-                       if (opform->oprcom == tup->t_data->t_oid)
-                       {
-                               if ((ltree != NULL) && (rtree != NULL))
-                               {
-                                       tree = *ltree;
-                                       *ltree = *rtree;
-                                       *rtree = tree;
-                               }
-                       }
-                       /* disable for now... - thomas 1998-05-14 */
-                       else
-                               tup = NULL;
-               }
-               if (!HeapTupleIsValid(tup) && (!noWarnings))
-                       op_error(op, arg1, arg2);
-       }
-
-       return tup;
+       return (Operator) tup;
 }      /* oper_exact() */
 
 
 /* oper_inexact()
- * Given operator, types of arg1, and arg2, return oper struct.
+ * Given operator, types of arg1, and arg2, return oper struct or NULL.
  * Inputs:
  * arg1, arg2: Type IDs
  */
-Operator
-oper_inexact(char *op, Oid arg1, Oid arg2, Node **ltree, Node **rtree, bool noWarnings)
+static Operator
+oper_inexact(char *op, Oid arg1, Oid arg2)
 {
        HeapTuple       tup;
        CandidateList candidates;
@@ -458,13 +425,9 @@ oper_inexact(char *op, Oid arg1, Oid arg2, Node **ltree, Node **rtree, bool noWa
 
        ncandidates = binary_oper_get_candidates(op, arg1, arg2, &candidates);
 
-       /* No operators found? Then throw error or return null... */
+       /* No operators found? Then return null... */
        if (ncandidates == 0)
-       {
-               if (!noWarnings)
-                       op_error(op, arg1, arg2);
                return NULL;
-       }
 
        /* Or found exactly one? Then proceed... */
        else if (ncandidates == 1)
@@ -493,18 +456,6 @@ oper_inexact(char *op, Oid arg1, Oid arg2, Node **ltree, Node **rtree, bool noWa
                }
                else
                        tup = NULL;
-
-               /* Could not choose one, for whatever reason... */
-               if (!HeapTupleIsValid(tup))
-               {
-                       if (!noWarnings)
-                       {
-                               elog(ERROR, "Unable to identify an operator '%s' for types '%s' and '%s'"
-                                        "\n\tYou will have to retype this query using an explicit cast",
-                                        op, typeTypeName(typeidType(arg1)), typeTypeName(typeidType(arg2)));
-                       }
-                       return NULL;
-               }
        }
        return (Operator) tup;
 }      /* oper_inexact() */
@@ -521,17 +472,16 @@ oper(char *opname, Oid ltypeId, Oid rtypeId, bool noWarnings)
        HeapTuple       tup;
 
        /* check for exact match on this operator... */
-       if (HeapTupleIsValid(tup = oper_exact(opname, ltypeId, rtypeId, NULL, NULL, TRUE)))
+       if (HeapTupleIsValid(tup = oper_exact(opname, ltypeId, rtypeId)))
        {
        }
        /* try to find a match on likely candidates... */
-       else if (HeapTupleIsValid(tup = oper_inexact(opname, ltypeId, rtypeId, NULL, NULL, TRUE)))
+       else if (HeapTupleIsValid(tup = oper_inexact(opname, ltypeId, rtypeId)))
        {
        }
        else if (!noWarnings)
        {
-               elog(ERROR, "Unable to identify a binary operator '%s' for types %s and %s",
-                        opname, typeTypeName(typeidType(ltypeId)), typeTypeName(typeidType(rtypeId)));
+               op_error(opname, ltypeId, rtypeId);
        }
 
        return (Operator) tup;
@@ -741,8 +691,7 @@ op_error(char *op, Oid arg1, Oid arg2)
                         "\n\tProbably a bad attribute name", op);
        }
 
-       elog(ERROR, "There is no operator '%s' for types '%s' and '%s'"
-                "\n\tYou will either have to retype this query using an explicit cast,"
-        "\n\tor you will have to define the operator using CREATE OPERATOR",
+       elog(ERROR, "Unable to identify an operator '%s' for types '%s' and '%s'"
+                "\n\tYou will have to retype this query using an explicit cast",
                 op, typeTypeName(tp1), typeTypeName(tp2));
 }

diff --git a/src/include/parser/parse_node.h b/src/include/parser/parse_node.h
index 1591743e0646acf1e2c31e53e12579d1a1b935bd..125305883df682dbd10c854c358ac0007f1f623b 100644 (file)
--- a/src/include/parser/parse_node.h
+++ b/src/include/parser/parse_node.h
@@ -5,7 +5,7 @@
  *
  * Copyright (c) 1994, Regents of the University of California
  *
- * $Id: parse_node.h,v 1.15 1999/07/19 00:26:17 tgl Exp $
+ * $Id: parse_node.h,v 1.16 1999/08/23 23:48:37 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -33,6 +33,8 @@ typedef struct ParseState
 
 extern ParseState *make_parsestate(ParseState *parentParseState);
 extern Expr *make_op(char *opname, Node *ltree, Node *rtree);
+extern Node *make_operand(char *opname, Node *tree,
+                                                 Oid orig_typeId, Oid target_typeId);
 extern Var *make_var(ParseState *pstate, Oid relid, char *refname,
                 char *attrname);
 extern ArrayRef *transformArraySubscripts(ParseState *pstate,

diff --git a/src/include/parser/parse_oper.h b/src/include/parser/parse_oper.h
index 82e241ef87e2794bdaa8074f793872eeee0349a6..7c3f3b54c7777b87e9cf278d093dfd2b005331af 100644 (file)
--- a/src/include/parser/parse_oper.h
+++ b/src/include/parser/parse_oper.h
@@ -6,7 +6,7 @@
  *
  * Copyright (c) 1994, Regents of the University of California
  *
- * $Id: parse_oper.h,v 1.8 1999/07/15 15:21:27 momjian Exp $
+ * $Id: parse_oper.h,v 1.9 1999/08/23 23:48:38 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -23,7 +23,4 @@ extern Operator oper(char *op, Oid arg1, Oid arg2, bool noWarnings);
 extern Operator right_oper(char *op, Oid arg);
 extern Operator left_oper(char *op, Oid arg);
 
-extern Operator oper_exact(char *op, Oid arg1, Oid arg2, Node **ltree, Node **rtree, bool noWarnings);
-extern Operator oper_inexact(char *op, Oid arg1, Oid arg2, Node **ltree, Node **rtree, bool noWarnings);
-
 #endif  /* PARSE_OPER_H */