Fix for bug #866. 7.3 contains new logic for avoiding redundant calls to

the index AM when we know we are fetching a unique row.  However, this
logic did not consider the possibility that it would be asked to fetch
backwards.  Also fix mark/restore to work correctly in this scenario.

diff --git a/src/backend/access/index/genam.c b/src/backend/access/index/genam.c
index 2a21e2962e9298de34b994e18e03c6628d2a130d..18eee722d3b8b33caf54b6ecea24ffb54abadc9f 100644 (file)
--- a/src/backend/access/index/genam.c
+++ b/src/backend/access/index/genam.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *   $Header: /cvsroot/pgsql/src/backend/access/index/genam.c,v 1.36 2002/09/04 20:31:09 momjian Exp $
+ *   $Header: /cvsroot/pgsql/src/backend/access/index/genam.c,v 1.37 2003/01/08 19:41:40 tgl Exp $
  *
  * NOTES
  *   many of the old access method routines have been turned into
@@ -107,6 +107,9 @@ RelationGetIndexScan(Relation indexRelation,
    /* mark cached function lookup data invalid; it will be set later */
    scan->fn_getnext.fn_oid = InvalidOid;
 
+   scan->unique_tuple_pos = 0;
+   scan->unique_tuple_mark = 0;
+
    pgstat_initstats(&scan->xs_pgstat_info, indexRelation);
 
    /*

diff --git a/src/backend/access/index/indexam.c b/src/backend/access/index/indexam.c
index d2e11d2a8d0516b384da5ed2dd61e778bb0d7195..258eb546a4911d572888e4ced35f6be0cb879cdd 100644 (file)
--- a/src/backend/access/index/indexam.c
+++ b/src/backend/access/index/indexam.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *   $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.62 2002/09/04 20:31:09 momjian Exp $
+ *   $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.63 2003/01/08 19:41:40 tgl Exp $
  *
  * INTERFACE ROUTINES
  *     index_open      - open an index relation by relation OID
@@ -308,6 +308,8 @@ index_rescan(IndexScanDesc scan, ScanKey key)
    scan->kill_prior_tuple = false;     /* for safety */
    scan->keys_are_unique = false;      /* may be set by amrescan */
    scan->got_tuple = false;
+   scan->unique_tuple_pos = 0;
+   scan->unique_tuple_mark = 0;
 
    OidFunctionCall2(procedure,
                     PointerGetDatum(scan),
@@ -360,6 +362,8 @@ index_markpos(IndexScanDesc scan)
    SCAN_CHECKS;
    GET_SCAN_PROCEDURE(markpos, ammarkpos);
 
+   scan->unique_tuple_mark = scan->unique_tuple_pos;
+
    OidFunctionCall1(procedure, PointerGetDatum(scan));
 }
 
@@ -376,7 +380,13 @@ index_restrpos(IndexScanDesc scan)
    GET_SCAN_PROCEDURE(restrpos, amrestrpos);
 
    scan->kill_prior_tuple = false;     /* for safety */
-   scan->got_tuple = false;
+
+   /*
+    * We do not reset got_tuple; so if the scan is actually being
+    * short-circuited by index_getnext, the effective position restoration
+    * is done by restoring unique_tuple_pos.
+    */
+   scan->unique_tuple_pos = scan->unique_tuple_mark;
 
    OidFunctionCall1(procedure, PointerGetDatum(scan));
 }
@@ -398,6 +408,32 @@ index_getnext(IndexScanDesc scan, ScanDirection direction)
 
    SCAN_CHECKS;
 
+   /*
+    * Can skip entering the index AM if we already got a tuple and it
+    * must be unique.  Instead, we need a "short circuit" path that
+    * just keeps track of logical scan position (before/on/after tuple).
+    *
+    * Note that we hold the pin on the single tuple's buffer throughout
+    * the scan once we are in this state.
+    */
+   if (scan->keys_are_unique && scan->got_tuple)
+   {
+       if (ScanDirectionIsForward(direction))
+       {
+           if (scan->unique_tuple_pos <= 0)
+               scan->unique_tuple_pos++;
+       }
+       else if (ScanDirectionIsBackward(direction))
+       {
+           if (scan->unique_tuple_pos >= 0)
+               scan->unique_tuple_pos--;
+       }
+       if (scan->unique_tuple_pos == 0)
+           return heapTuple;
+       else
+           return NULL;
+   }
+
    /* Release any previously held pin */
    if (BufferIsValid(scan->xs_cbuf))
    {
@@ -408,13 +444,6 @@ index_getnext(IndexScanDesc scan, ScanDirection direction)
    /* just make sure this is false... */
    scan->kill_prior_tuple = false;
 
-   /*
-    * Can skip entering the index AM if we already got a tuple and it
-    * must be unique.
-    */
-   if (scan->keys_are_unique && scan->got_tuple)
-       return NULL;
-
    for (;;)
    {
        bool        found;
@@ -475,6 +504,12 @@ index_getnext(IndexScanDesc scan, ScanDirection direction)
    /* Success exit */
    scan->got_tuple = true;
 
+   /*
+    * If we just fetched a known-unique tuple, then subsequent calls will
+    * go through the short-circuit code above.  unique_tuple_pos has been
+    * initialized to 0, which is the correct state ("on row").
+    */
+
    pgstat_count_index_getnext(&scan->xs_pgstat_info);
 
    return heapTuple;

diff --git a/src/include/access/relscan.h b/src/include/access/relscan.h
index 06b5701cf842ee118549a2603eb391f00d6dc126..898afa64bb5aacdeda9a3f62e5160759892bc2c3 100644 (file)
--- a/src/include/access/relscan.h
+++ b/src/include/access/relscan.h
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: relscan.h,v 1.29 2002/09/04 20:31:37 momjian Exp $
+ * $Id: relscan.h,v 1.30 2003/01/08 19:41:40 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -70,6 +70,15 @@ typedef struct IndexScanDescData
 
    FmgrInfo    fn_getnext;     /* cached lookup info for AM's getnext fn */
 
+   /*
+    * If keys_are_unique and got_tuple are both true, we stop calling the
+    * index AM; it is then necessary for index_getnext to keep track of
+    * the logical scan position for itself.  It does that using
+    * unique_tuple_pos: -1 = before row, 0 = on row, +1 = after row.
+    */
+   int         unique_tuple_pos; /* logical position */
+   int         unique_tuple_mark; /* logical marked position */
+
    PgStat_Info xs_pgstat_info; /* statistics collector hook */
 } IndexScanDescData;