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 5de9048a762489aa484151f6141d789139f79c75..e993a9124ad972b423b9784d1b02525c6829ce75 100644 (file)
--- a/src/backend/access/index/genam.c
+++ b/src/backend/access/index/genam.c
@@ -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 c14f1623a9be27d6c276de626c8a5609622db7cd..85a001663ff73b60ac0f7547b0d66df932adb6a1 100644 (file)
--- a/src/backend/access/index/indexam.c
+++ b/src/backend/access/index/indexam.c
@@ -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 29eb1b301b236b396b9ff1a77fa3038c8b5f20e6..611eefd11333a85592e41433ee64e6399b1b1540 100644 (file)
--- a/src/include/access/relscan.h
+++ b/src/include/access/relscan.h
@@ -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;