New nodeGroup.c code uses own copy of first tuple in a group.

Free memory after comparison in nodeUnique.c

diff --git a/src/backend/executor/nodeGroup.c b/src/backend/executor/nodeGroup.c
index 59e1e0c20441e616d864bd808da4e3a65a59d3be..fa733e2da09f12b6a0337403b276ca982e0b1508 100644 (file)
--- a/src/backend/executor/nodeGroup.c
+++ b/src/backend/executor/nodeGroup.c
@@ -13,7 +13,7 @@
  *       columns. (ie. tuples from the same group are consecutive)
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/executor/nodeGroup.c,v 1.16 1998/02/10 16:02:58 momjian Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/executor/nodeGroup.c,v 1.17 1998/02/18 12:40:43 vadim Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -31,7 +31,7 @@
 static TupleTableSlot *ExecGroupEveryTuple(Group *node);
 static TupleTableSlot *ExecGroupOneTuple(Group *node);
 static bool
-sameGroup(TupleTableSlot *oldslot, TupleTableSlot *newslot,
+sameGroup(HeapTuple oldslot, HeapTuple newslot,
                  int numCols, AttrNumber *grpColIdx, TupleDesc tupdesc);
 
 /* ---------------------------------------
@@ -71,8 +71,8 @@ ExecGroupEveryTuple(Group *node)
        ExprContext *econtext;
 
        HeapTuple       outerTuple = NULL;
-       TupleTableSlot *outerslot,
-                          *lastslot;
+       HeapTuple       firsttuple;
+       TupleTableSlot *outerslot;
        ProjectionInfo *projInfo;
        TupleTableSlot *resultSlot;
 
@@ -90,18 +90,14 @@ ExecGroupEveryTuple(Group *node)
 
        econtext = grpstate->csstate.cstate.cs_ExprContext;
 
-       if (grpstate->grp_useLastTuple)
+       /* if we haven't returned first tuple of new group yet ... */
+       if (grpstate->grp_useFirstTuple)
        {
+               grpstate->grp_useFirstTuple = FALSE;
 
-               /*
-                * we haven't returned last tuple yet because it is not of the
-                * same group
-                */
-               grpstate->grp_useLastTuple = FALSE;
-
-               ExecStoreTuple(grpstate->grp_lastSlot->val,
+               ExecStoreTuple(grpstate->grp_firstTuple,
                                           grpstate->csstate.css_ScanTupleSlot,
-                                          grpstate->grp_lastSlot->ttc_buffer,
+                                          InvalidBuffer,
                                           false);
        }
        else
@@ -115,29 +111,28 @@ ExecGroupEveryTuple(Group *node)
                        return NULL;
                }
 
-               /* ----------------
-                *      Compare with last tuple and see if this tuple is of
-                *      the same group.
-                * ----------------
-                */
-               lastslot = grpstate->csstate.css_ScanTupleSlot;
-
-               if (lastslot->val != NULL &&
-                       (!sameGroup(lastslot, outerslot,
-                                               node->numCols, node->grpColIdx,
-                                               ExecGetScanType(&grpstate->csstate))))
+               firsttuple = grpstate->grp_firstTuple;
+               /* this should occur on the first call only */
+               if (firsttuple == NULL) 
+               {
+                       grpstate->grp_firstTuple = heap_copytuple (outerTuple);
+               }
+               else
                {
-/*                                             ExecGetResultType(&grpstate->csstate.cstate)))) {*/
-
-                       grpstate->grp_useLastTuple = TRUE;
-
-                       /* save it for next time */
-                       grpstate->grp_lastSlot = outerslot;
-
                        /*
-                        * signifies the end of the group
+                        *      Compare with first tuple and see if this tuple is of
+                        *      the same group.
                         */
-                       return NULL;
+                       if (!sameGroup(firsttuple, outerslot->val,
+                                               node->numCols, node->grpColIdx,
+                                               ExecGetScanType(&grpstate->csstate)))
+                       {
+                               grpstate->grp_useFirstTuple = TRUE;
+                               pfree (firsttuple);
+                               grpstate->grp_firstTuple = heap_copytuple (outerTuple);
+                               
+                               return NULL;    /* signifies the end of the group */
+                       }
                }
 
                ExecStoreTuple(outerTuple,
@@ -172,8 +167,8 @@ ExecGroupOneTuple(Group *node)
        ExprContext *econtext;
 
        HeapTuple       outerTuple = NULL;
-       TupleTableSlot *outerslot,
-                          *lastslot;
+       HeapTuple       firsttuple;
+       TupleTableSlot *outerslot;
        ProjectionInfo *projInfo;
        TupleTableSlot *resultSlot;
 
@@ -191,15 +186,9 @@ ExecGroupOneTuple(Group *node)
 
        econtext = node->grpstate->csstate.cstate.cs_ExprContext;
 
-       if (grpstate->grp_useLastTuple)
-       {
-               grpstate->grp_useLastTuple = FALSE;
-               ExecStoreTuple(grpstate->grp_lastSlot->val,
-                                          grpstate->csstate.css_ScanTupleSlot,
-                                          grpstate->grp_lastSlot->ttc_buffer,
-                                          false);
-       }
-       else
+       firsttuple = grpstate->grp_firstTuple;
+       /* this should occur on the first call only */
+       if (firsttuple == NULL) 
        {
                outerslot = ExecProcNode(outerPlan(node), (Plan *) node);
                if (outerslot)
@@ -209,12 +198,8 @@ ExecGroupOneTuple(Group *node)
                        grpstate->grp_done = TRUE;
                        return NULL;
                }
-               ExecStoreTuple(outerTuple,
-                                          grpstate->csstate.css_ScanTupleSlot,
-                                          outerslot->ttc_buffer,
-                                          false);
+               grpstate->grp_firstTuple = firsttuple = heap_copytuple (outerTuple);
        }
-       lastslot = grpstate->csstate.css_ScanTupleSlot;
 
        /*
         * find all tuples that belong to a group
@@ -225,49 +210,21 @@ ExecGroupOneTuple(Group *node)
                outerTuple = (outerslot) ? outerslot->val : NULL;
                if (!HeapTupleIsValid(outerTuple))
                {
-
-                       /*
-                        * we have at least one tuple (lastslot) if we reach here
-                        */
                        grpstate->grp_done = TRUE;
-
-                       /* return lastslot */
                        break;
                }
 
                /* ----------------
-                *      Compare with last tuple and see if this tuple is of
+                *      Compare with first tuple and see if this tuple is of
                 *      the same group.
                 * ----------------
                 */
-               if ((!sameGroup(lastslot, outerslot,
+               if ((!sameGroup(firsttuple, outerslot->val,
                                                node->numCols, node->grpColIdx,
                                                ExecGetScanType(&grpstate->csstate))))
-               {
-/*                                             ExecGetResultType(&grpstate->csstate.cstate)))) {*/
-
-                       grpstate->grp_useLastTuple = TRUE;
-
-                       /* save it for next time */
-                       grpstate->grp_lastSlot = outerslot;
-
-                       /* return lastslot */
                        break;
-               }
-
-               ExecStoreTuple(outerTuple,
-                                          grpstate->csstate.css_ScanTupleSlot,
-                                          outerslot->ttc_buffer,
-                                          false);
-
-               lastslot = grpstate->csstate.css_ScanTupleSlot;
        }
 
-       ExecStoreTuple(lastslot->val,
-                                  grpstate->csstate.css_ScanTupleSlot,
-                                  lastslot->ttc_buffer,
-                                  false);
-
        /* ----------------
         *      form a projection tuple, store it in the result tuple
         *      slot and return it.
@@ -275,8 +232,19 @@ ExecGroupOneTuple(Group *node)
         */
        projInfo = grpstate->csstate.cstate.cs_ProjInfo;
 
-       econtext->ecxt_scantuple = lastslot;
+       ExecStoreTuple(firsttuple,
+                                  grpstate->csstate.css_ScanTupleSlot,
+                                  InvalidBuffer,
+                                  false);
+       econtext->ecxt_scantuple = grpstate->csstate.css_ScanTupleSlot;
        resultSlot = ExecProject(projInfo, &isDone);
+       
+       /* save outerTuple if we are not done yet */
+       if (!grpstate->grp_done)
+       {
+               pfree (firsttuple);
+               grpstate->grp_firstTuple = heap_copytuple (outerTuple);
+       }
 
        return resultSlot;
 }
@@ -304,7 +272,7 @@ ExecInitGroup(Group *node, EState *estate, Plan *parent)
         */
        grpstate = makeNode(GroupState);
        node->grpstate = grpstate;
-       grpstate->grp_useLastTuple = FALSE;
+       grpstate->grp_useFirstTuple = FALSE;
        grpstate->grp_done = FALSE;
 
        /*
@@ -370,6 +338,11 @@ ExecEndGroup(Group *node)
 
        /* clean up tuple table */
        ExecClearTuple(grpstate->csstate.css_ScanTupleSlot);
+       if (grpstate->grp_firstTuple != NULL)
+       {
+               pfree (grpstate->grp_firstTuple);
+               grpstate->grp_firstTuple = NULL;
+       }
 }
 
 /*****************************************************************************
@@ -380,8 +353,8 @@ ExecEndGroup(Group *node)
  * code swiped from nodeUnique.c
  */
 static bool
-sameGroup(TupleTableSlot *oldslot,
-                 TupleTableSlot *newslot,
+sameGroup(HeapTuple oldtuple,
+                 HeapTuple newtuple,
                  int numCols,
                  AttrNumber *grpColIdx,
                  TupleDesc tupdesc)
@@ -401,12 +374,12 @@ sameGroup(TupleTableSlot *oldslot,
                att = grpColIdx[i];
                typoutput = typtoout((Oid) tupdesc->attrs[att - 1]->atttypid);
 
-               attr1 = heap_getattr(oldslot->val,
+               attr1 = heap_getattr(oldtuple,
                                                         att,
                                                         tupdesc,
                                                         &isNull1);
 
-               attr2 = heap_getattr(newslot->val,
+               attr2 = heap_getattr(newtuple,
                                                         att,
                                                         tupdesc,
                                                         &isNull2);

diff --git a/src/backend/executor/nodeUnique.c b/src/backend/executor/nodeUnique.c
index abdf44bc89071bb40de7c1e44b9f296ba1d85607..ddeae78904d9106bf226dc28664816e44ae556e5 100644 (file)
--- a/src/backend/executor/nodeUnique.c
+++ b/src/backend/executor/nodeUnique.c
@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/executor/nodeUnique.c,v 1.14 1998/02/10 16:03:03 momjian Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/executor/nodeUnique.c,v 1.15 1998/02/18 12:40:44 vadim Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -208,9 +208,14 @@ ExecUnique(Unique *node)
                                 * use strcmp for comparison
                                 */
                                if (strcmp(val1, val2) == 0)    /* they are equal */
+                               {
+                                       pfree (val1);
+                                       pfree (val2);
                                        continue;
-                               else
-                                       break;
+                               }
+                               pfree (val1);
+                               pfree (val2);
+                               break;
                        }
                        else
 /* one is null and the other isn't, they aren't equal */