Give left_oper() and right_oper() noError parameters like oper() (the

binary case) already has.  Needed for upcoming ruleutils change.

diff --git a/src/backend/parser/parse_node.c b/src/backend/parser/parse_node.c
index 5c02e9b..2c44670 100644 (file)
--- a/src/backend/parser/parse_node.c
+++ b/src/backend/parser/parse_node.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.63 2002/04/25 02:56:55 tgl Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.64 2002/05/01 19:26:07 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -109,7 +109,7 @@ make_op(List *opname, Node *ltree, Node *rtree)
        /* right operator? */
        if (rtree == NULL)
        {
-               tup = right_oper(opname, ltypeId);
+               tup = right_oper(opname, ltypeId, false);
                opform = (Form_pg_operator) GETSTRUCT(tup);
                left = make_operand(ltree, ltypeId, opform->oprleft);
                right = NULL;
@@ -118,7 +118,7 @@ make_op(List *opname, Node *ltree, Node *rtree)
        /* left operator? */
        else if (ltree == NULL)
        {
-               tup = left_oper(opname, rtypeId);
+               tup = left_oper(opname, rtypeId, false);
                opform = (Form_pg_operator) GETSTRUCT(tup);
                right = make_operand(rtree, rtypeId, opform->oprright);
                left = NULL;

diff --git a/src/backend/parser/parse_oper.c b/src/backend/parser/parse_oper.c
index 52ae39c..d52417b 100644 (file)
--- a/src/backend/parser/parse_oper.c
+++ b/src/backend/parser/parse_oper.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/parser/parse_oper.c,v 1.55 2002/04/16 23:08:11 tgl Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/parser/parse_oper.c,v 1.56 2002/05/01 19:26:07 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -751,19 +751,21 @@ compatible_oper_funcid(List *op, Oid arg1, Oid arg2, bool noError)
 }
 
 
-/* Given unary right operator (operator on right), return oper struct
+/* right_oper() -- search for a unary right operator (operator on right)
+ * Given operator name and type of arg, return oper struct.
  *
  * IMPORTANT: the returned operator (if any) is only promised to be
  * coercion-compatible with the input datatype.  Do not use this if
  * you need an exact- or binary-compatible match.
  *
- * Always raises error on failure.
+ * If no matching operator found, return NULL if noError is true,
+ * raise an error if it is false.
  *
  * NOTE: on success, the returned object is a syscache entry.  The caller
  * must ReleaseSysCache() the entry when done with it.
  */
 Operator
-right_oper(List *op, Oid arg)
+right_oper(List *op, Oid arg, bool noError)
 {
        FuncCandidateList clist;
        Oid                     operOid = InvalidOid;
@@ -804,26 +806,28 @@ right_oper(List *op, Oid arg)
                                                                 0, 0, 0);
        }
 
-       if (!HeapTupleIsValid(tup))
+       if (!HeapTupleIsValid(tup) && !noError)
                unary_op_error(op, arg, FALSE);
 
        return (Operator) tup;
-}      /* right_oper() */
+}
 
 
-/* Given unary left operator (operator on left), return oper struct
+/* left_oper() -- search for a unary left operator (operator on left)
+ * Given operator name and type of arg, return oper struct.
  *
  * IMPORTANT: the returned operator (if any) is only promised to be
  * coercion-compatible with the input datatype.  Do not use this if
  * you need an exact- or binary-compatible match.
  *
- * Always raises error on failure.
+ * If no matching operator found, return NULL if noError is true,
+ * raise an error if it is false.
  *
  * NOTE: on success, the returned object is a syscache entry.  The caller
  * must ReleaseSysCache() the entry when done with it.
  */
 Operator
-left_oper(List *op, Oid arg)
+left_oper(List *op, Oid arg, bool noError)
 {
        FuncCandidateList clist;
        Oid                     operOid = InvalidOid;
@@ -869,11 +873,11 @@ left_oper(List *op, Oid arg)
                                                                 0, 0, 0);
        }
 
-       if (!HeapTupleIsValid(tup))
+       if (!HeapTupleIsValid(tup) && !noError)
                unary_op_error(op, arg, TRUE);
 
        return (Operator) tup;
-}      /* left_oper() */
+}
 
 
 /* op_error()

diff --git a/src/include/parser/parse_oper.h b/src/include/parser/parse_oper.h
index 5793c16..0394cb5 100644 (file)
--- a/src/include/parser/parse_oper.h
+++ b/src/include/parser/parse_oper.h
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: parse_oper.h,v 1.19 2002/04/16 23:08:12 tgl Exp $
+ * $Id: parse_oper.h,v 1.20 2002/05/01 19:26:08 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -27,8 +27,8 @@ extern Oid    LookupOperNameTypeNames(List *opername, TypeName *oprleft,
 /* Routines to find operators matching a name and given input types */
 /* NB: the selected operator may require coercion of the input types! */
 extern Operator oper(List *op, Oid arg1, Oid arg2, bool noError);
-extern Operator right_oper(List *op, Oid arg);
-extern Operator left_oper(List *op, Oid arg);
+extern Operator right_oper(List *op, Oid arg, bool noError);
+extern Operator left_oper(List *op, Oid arg, bool noError);
 
 /* Routines to find operators that DO NOT require coercion --- ie, their */
 /* input types are either exactly as given, or binary-compatible */