Here's a combination of all the patches I'm currently waiting

    for against a just updated CVS tree. It contains

        Partial new rewrite system that handles subselects,  view
        aggregate  columns, insert into select from view, updates
        with set col = view-value and select rules restriction to
        view definition.

        Updates  for  rule/view  backparsing utility functions to
        handle subselects correct.


        New system views pg_tables and pg_indexes (where you  can
        see the complete index definition in the latter one).

        Enabling array references on query parameters.

        Bugfix for functional index.

        Little changes to system views pg_rules and pg_views.


    The rule system isn't a release-stopper any longer.

    But  another  stopper  is  that  I  don't  know if the latest
    changes to PL/pgSQL (not already in CVS) made it  compile  on
    AIX. Still wait for some response from Dave.

Jan

1 files changed, 108 insertions, 1 deletions

diff --git a/src/backend/rewrite/rewriteManip.c b/src/backend/rewrite/rewriteManip.c
index 15c68064a6a..87786d9cdd0 100644
--- a/src/backend/rewrite/rewriteManip.c
+++ b/src/backend/rewrite/rewriteManip.c
@@ -6,7 +6,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteManip.c,v 1.18 1998/09/11 16:39:59 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteManip.c,v 1.19 1998/10/02 16:27:49 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -73,6 +73,23 @@ OffsetVarNodes(Node *node, int offset)
 				OffsetVarNodes((Node *) expr->args, offset);
 			}
 			break;
+		case T_Iter:
+			{
+				Iter	   *iter = (Iter *) node;
+
+				OffsetVarNodes((Node *) iter->iterexpr, offset);
+			}
+			break;
+		case T_ArrayRef:
+			{
+				ArrayRef	   *ref = (ArrayRef *) node;
+
+				OffsetVarNodes((Node *) ref->refupperindexpr, offset);
+				OffsetVarNodes((Node *) ref->reflowerindexpr, offset);
+				OffsetVarNodes((Node *) ref->refexpr, offset);
+				OffsetVarNodes((Node *) ref->refassgnexpr, offset);
+			}
+			break;
 		case T_Var:
 			{
 				Var		   *var = (Var *) node;
@@ -157,6 +174,23 @@ ChangeVarNodes(Node *node, int old_varno, int new_varno, int sublevels_up)
 				ChangeVarNodes((Node *) expr->args, old_varno, new_varno, sublevels_up);
 			}
 			break;
+		case T_Iter:
+			{
+				Iter	   *iter = (Iter *) node;
+
+				ChangeVarNodes((Node *) iter->iterexpr, old_varno, new_varno, sublevels_up);
+			}
+			break;
+		case T_ArrayRef:
+			{
+				ArrayRef	   *ref = (ArrayRef *) node;
+
+				ChangeVarNodes((Node *) ref->refupperindexpr, old_varno, new_varno, sublevels_up);
+				ChangeVarNodes((Node *) ref->reflowerindexpr, old_varno, new_varno, sublevels_up);
+				ChangeVarNodes((Node *) ref->refexpr, old_varno, new_varno, sublevels_up);
+				ChangeVarNodes((Node *) ref->refassgnexpr, old_varno, new_varno, sublevels_up);
+			}
+			break;
 		case T_Var:
 			{
 				Var		   *var = (Var *) node;
@@ -353,6 +387,20 @@ ResolveNew(RewriteInfo *info, List *targetlist, Node **nodePtr,
 			ResolveNew(info, targetlist, (Node **) (&(((Expr *) node)->args)),
 					   sublevels_up);
 			break;
+		case T_Iter:
+			ResolveNew(info, targetlist, (Node **) (&(((Iter *) node)->iterexpr)),
+					   sublevels_up);
+			break;
+		case T_ArrayRef:
+			ResolveNew(info, targetlist, (Node **) (&(((ArrayRef *) node)->refupperindexpr)),
+					   sublevels_up);
+			ResolveNew(info, targetlist, (Node **) (&(((ArrayRef *) node)->reflowerindexpr)),
+					   sublevels_up);
+			ResolveNew(info, targetlist, (Node **) (&(((ArrayRef *) node)->refexpr)),
+					   sublevels_up);
+			ResolveNew(info, targetlist, (Node **) (&(((ArrayRef *) node)->refassgnexpr)),
+					   sublevels_up);
+			break;
 		case T_Var:
 			{
 				int			this_varno = (int) ((Var *) node)->varno;
@@ -454,6 +502,38 @@ nodeHandleRIRAttributeRule(Node **nodePtr,
 										   sublevels_up);
 			}
 			break;
+		case T_Iter:
+			{
+				Iter	   *iter = (Iter *) node;
+
+				nodeHandleRIRAttributeRule((Node **) (&(iter->iterexpr)), rtable,
+										   targetlist, rt_index, attr_num,
+										   modified, badsql,
+										   sublevels_up);
+			}
+			break;
+		case T_ArrayRef:
+			{
+				ArrayRef	   *ref = (ArrayRef *) node;
+
+				nodeHandleRIRAttributeRule((Node **) (&(ref->refupperindexpr)), rtable,
+										   targetlist, rt_index, attr_num,
+										   modified, badsql,
+										   sublevels_up);
+				nodeHandleRIRAttributeRule((Node **) (&(ref->reflowerindexpr)), rtable,
+										   targetlist, rt_index, attr_num,
+										   modified, badsql,
+										   sublevels_up);
+				nodeHandleRIRAttributeRule((Node **) (&(ref->refexpr)), rtable,
+										   targetlist, rt_index, attr_num,
+										   modified, badsql,
+										   sublevels_up);
+				nodeHandleRIRAttributeRule((Node **) (&(ref->refassgnexpr)), rtable,
+										   targetlist, rt_index, attr_num,
+										   modified, badsql,
+										   sublevels_up);
+			}
+			break;
 		case T_Var:
 			{
 				int			this_varno = ((Var *) node)->varno;
@@ -598,6 +678,33 @@ nodeHandleViewRule(Node **nodePtr,
 								   rt_index, modified, sublevels_up);
 			}
 			break;
+		case T_Iter:
+			{
+				Iter	   *iter = (Iter *) node;
+
+				nodeHandleViewRule((Node **) (&(iter->iterexpr)),
+								   rtable, targetlist,
+								   rt_index, modified, sublevels_up);
+			}
+			break;
+		case T_ArrayRef:
+			{
+				ArrayRef	   *ref = (ArrayRef *) node;
+
+				nodeHandleViewRule((Node **) (&(ref->refupperindexpr)),
+								   rtable, targetlist,
+								   rt_index, modified, sublevels_up);
+				nodeHandleViewRule((Node **) (&(ref->reflowerindexpr)),
+								   rtable, targetlist,
+								   rt_index, modified, sublevels_up);
+				nodeHandleViewRule((Node **) (&(ref->refexpr)),
+								   rtable, targetlist,
+								   rt_index, modified, sublevels_up);
+				nodeHandleViewRule((Node **) (&(ref->refassgnexpr)),
+								   rtable, targetlist,
+								   rt_index, modified, sublevels_up);
+			}
+			break;
 		case T_Var:
 			{
 				Var		   *var = (Var *) node;