Support UPDATE/DELETE WHERE CURRENT OF cursor_name, per SQL standard.

[postgresql] / src / backend / nodes / equalfuncs.c

diff --git a/src/backend/nodes/equalfuncs.c b/src/backend/nodes/equalfuncs.c
index ae247dfa3ea11366656104f1621e4ae0f2e9d534..04072c7a65422560271d422496ac86230e40f817 100644 (file)
--- a/src/backend/nodes/equalfuncs.c
+++ b/src/backend/nodes/equalfuncs.c
@@ -18,7 +18,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *       $PostgreSQL: pgsql/src/backend/nodes/equalfuncs.c,v 1.301 2007/03/13 00:33:40 tgl Exp $
+ *       $PostgreSQL: pgsql/src/backend/nodes/equalfuncs.c,v 1.309 2007/06/11 01:16:22 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -139,6 +139,7 @@ static bool
 _equalConst(Const *a, Const *b)
 {
        COMPARE_SCALAR_FIELD(consttype);
+       COMPARE_SCALAR_FIELD(consttypmod);
        COMPARE_SCALAR_FIELD(constlen);
        COMPARE_SCALAR_FIELD(constisnull);
        COMPARE_SCALAR_FIELD(constbyval);
@@ -180,9 +181,9 @@ _equalAggref(Aggref *a, Aggref *b)
 static bool
 _equalArrayRef(ArrayRef *a, ArrayRef *b)
 {
-       COMPARE_SCALAR_FIELD(refrestype);
        COMPARE_SCALAR_FIELD(refarraytype);
        COMPARE_SCALAR_FIELD(refelemtype);
+       COMPARE_SCALAR_FIELD(reftypmod);
        COMPARE_NODE_FIELD(refupperindexpr);
        COMPARE_NODE_FIELD(reflowerindexpr);
        COMPARE_NODE_FIELD(refexpr);
@@ -358,6 +359,45 @@ _equalRelabelType(RelabelType *a, RelabelType *b)
        return true;
 }
 
+static bool
+_equalCoerceViaIO(CoerceViaIO *a, CoerceViaIO *b)
+{
+       COMPARE_NODE_FIELD(arg);
+       COMPARE_SCALAR_FIELD(resulttype);
+
+       /*
+        * Special-case COERCE_DONTCARE, so that planner can build coercion nodes
+        * that are equal() to both explicit and implicit coercions.
+        */
+       if (a->coerceformat != b->coerceformat &&
+               a->coerceformat != COERCE_DONTCARE &&
+               b->coerceformat != COERCE_DONTCARE)
+               return false;
+
+       return true;
+}
+
+static bool
+_equalArrayCoerceExpr(ArrayCoerceExpr *a, ArrayCoerceExpr *b)
+{
+       COMPARE_NODE_FIELD(arg);
+       COMPARE_SCALAR_FIELD(elemfuncid);
+       COMPARE_SCALAR_FIELD(resulttype);
+       COMPARE_SCALAR_FIELD(resulttypmod);
+       COMPARE_SCALAR_FIELD(isExplicit);
+
+       /*
+        * Special-case COERCE_DONTCARE, so that planner can build coercion nodes
+        * that are equal() to both explicit and implicit coercions.
+        */
+       if (a->coerceformat != b->coerceformat &&
+               a->coerceformat != COERCE_DONTCARE &&
+               b->coerceformat != COERCE_DONTCARE)
+               return false;
+
+       return true;
+}
+
 static bool
 _equalConvertRowtypeExpr(ConvertRowtypeExpr *a, ConvertRowtypeExpr *b)
 {
@@ -558,6 +598,15 @@ _equalSetToDefault(SetToDefault *a, SetToDefault *b)
        return true;
 }
 
+static bool
+_equalCurrentOfExpr(CurrentOfExpr *a, CurrentOfExpr *b)
+{
+       COMPARE_SCALAR_FIELD(cvarno);
+       COMPARE_STRING_FIELD(cursor_name);
+
+       return true;
+}
+
 static bool
 _equalTargetEntry(TargetEntry *a, TargetEntry *b)
 {
@@ -658,6 +707,7 @@ _equalOuterJoinInfo(OuterJoinInfo *a, OuterJoinInfo *b)
        COMPARE_BITMAPSET_FIELD(min_righthand);
        COMPARE_SCALAR_FIELD(is_full_join);
        COMPARE_SCALAR_FIELD(lhs_strict);
+       COMPARE_SCALAR_FIELD(delay_upper_joins);
 
        return true;
 }
@@ -700,7 +750,7 @@ _equalQuery(Query *a, Query *b)
        COMPARE_SCALAR_FIELD(canSetTag);
        COMPARE_NODE_FIELD(utilityStmt);
        COMPARE_SCALAR_FIELD(resultRelation);
-       COMPARE_NODE_FIELD(into);
+       COMPARE_NODE_FIELD(intoClause);
        COMPARE_SCALAR_FIELD(hasAggs);
        COMPARE_SCALAR_FIELD(hasSubLinks);
        COMPARE_NODE_FIELD(rtable);
@@ -757,7 +807,7 @@ static bool
 _equalSelectStmt(SelectStmt *a, SelectStmt *b)
 {
        COMPARE_NODE_FIELD(distinctClause);
-       COMPARE_NODE_FIELD(into);
+       COMPARE_NODE_FIELD(intoClause);
        COMPARE_NODE_FIELD(targetList);
        COMPARE_NODE_FIELD(fromClause);
        COMPARE_NODE_FIELD(whereClause);
@@ -1164,6 +1214,15 @@ _equalCompositeTypeStmt(CompositeTypeStmt *a, CompositeTypeStmt *b)
        return true;
 }
 
+static bool
+_equalCreateEnumStmt(CreateEnumStmt *a, CreateEnumStmt *b)
+{
+       COMPARE_NODE_FIELD(typename);
+       COMPARE_NODE_FIELD(vals);
+
+       return true;
+}
+
 static bool
 _equalViewStmt(ViewStmt *a, ViewStmt *b)
 {
@@ -1345,6 +1404,14 @@ _equalVariableResetStmt(VariableResetStmt *a, VariableResetStmt *b)
        return true;
 }
 
+static bool
+_equalDiscardStmt(DiscardStmt *a, DiscardStmt *b)
+{
+       COMPARE_SCALAR_FIELD(target);
+
+       return true;
+}
+
 static bool
 _equalCreateTableSpaceStmt(CreateTableSpaceStmt *a, CreateTableSpaceStmt *b)
 {
@@ -2012,6 +2079,12 @@ equal(void *a, void *b)
                case T_RelabelType:
                        retval = _equalRelabelType(a, b);
                        break;
+               case T_CoerceViaIO:
+                       retval = _equalCoerceViaIO(a, b);
+                       break;
+               case T_ArrayCoerceExpr:
+                       retval = _equalArrayCoerceExpr(a, b);
+                       break;
                case T_ConvertRowtypeExpr:
                        retval = _equalConvertRowtypeExpr(a, b);
                        break;
@@ -2060,6 +2133,9 @@ equal(void *a, void *b)
                case T_SetToDefault:
                        retval = _equalSetToDefault(a, b);
                        break;
+               case T_CurrentOfExpr:
+                       retval = _equalCurrentOfExpr(a, b);
+                       break;
                case T_TargetEntry:
                        retval = _equalTargetEntry(a, b);
                        break;
@@ -2222,6 +2298,9 @@ equal(void *a, void *b)
                case T_CompositeTypeStmt:
                        retval = _equalCompositeTypeStmt(a, b);
                        break;
+               case T_CreateEnumStmt:
+                       retval = _equalCreateEnumStmt(a, b);
+                       break;
                case T_ViewStmt:
                        retval = _equalViewStmt(a, b);
                        break;
@@ -2276,6 +2355,9 @@ equal(void *a, void *b)
                case T_VariableResetStmt:
                        retval = _equalVariableResetStmt(a, b);
                        break;
+               case T_DiscardStmt:
+                       retval = _equalDiscardStmt(a, b);
+                       break;
                case T_CreateTableSpaceStmt:
                        retval = _equalCreateTableSpaceStmt(a, b);
                        break;