From 615fe2bbc747af5e05d0c3dc72b3b951a2a8ea36 Mon Sep 17 00:00:00 2001
From: Michael Stack <stack@apache.org>
Date: Tue, 15 Jan 2008 23:42:31 +0000
Subject: [PATCH] HADOOP-2592 Scanning, a region can let out a row that its not
 supposed to have

git-svn-id: https://svn.apache.org/repos/asf/lucene/hadoop/trunk/src/contrib/hbase@612314 13f79535-47bb-0310-9956-ffa450edef68
---
 CHANGES.txt                                   |  2 +
 .../org/apache/hadoop/hbase/HStoreFile.java   | 62 +++++++++++--------
 2 files changed, 39 insertions(+), 25 deletions(-)

diff --git a/CHANGES.txt b/CHANGES.txt
index 36511f8fd85..96af8eb808a 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -129,6 +129,8 @@ Trunk (unreleased changes)
                previously (Bryan Duxbury via Stack)
    HADOOP-2587 Splits blocked by compactions cause region to be offline for
                duration of compaction. 
+   HADOOP-2592 Scanning, a region can let out a row that its not supposed
+               to have
    
   IMPROVEMENTS
    HADOOP-2401 Add convenience put method that takes writable
diff --git a/src/java/org/apache/hadoop/hbase/HStoreFile.java b/src/java/org/apache/hadoop/hbase/HStoreFile.java
index ce1b08fcddc..3e553ae31f2 100644
--- a/src/java/org/apache/hadoop/hbase/HStoreFile.java
+++ b/src/java/org/apache/hadoop/hbase/HStoreFile.java
@@ -737,7 +737,7 @@ public class HStoreFile implements HConstants {
   static class HalfMapFileReader extends BloomFilterMapFile.Reader {
     private final boolean top;
     private final WritableComparable midkey;
-    private boolean topFirstNextCall = true;
+    private boolean firstNextCall = true;
     
     HalfMapFileReader(final FileSystem fs, final String dirName, 
         final Configuration conf, final Range r,
@@ -789,17 +789,32 @@ public class HStoreFile implements HConstants {
     @SuppressWarnings("unchecked")
     @Override
     public synchronized WritableComparable getClosest(WritableComparable key,
-        Writable val)
+      Writable val)
     throws IOException {
+      WritableComparable closest = null;
       if (top) {
-        if (key.compareTo(midkey) < 0) {
-          return midkey;
+        // If top, the lowest possible key is midkey.  Do not have to check
+        // what comes back from super getClosest.  Will return exact match or
+        // greater.
+        closest = (key.compareTo(this.midkey) < 0)?
+          this.midkey: super.getClosest(key, val);
+      } else {
+        // We're serving bottom of the file.
+        if (key.compareTo(this.midkey) < 0) {
+          // Check key is within range for bottom.
+          closest = super.getClosest(key, val);
+          // midkey was made against largest store file at time of split. Smaller
+          // store files could have anything in them.  Check return value is
+          // not beyond the midkey (getClosest returns exact match or next
+          // after).
+          if (closest != null && closest.compareTo(this.midkey) >= 0) {
+            // Don't let this value out.
+            closest = null;
+          }
         }
-      } else if (key.compareTo(midkey) >= 0) {
-        // Contract says return null if EOF.
-        return null;
+        // Else, key is > midkey so let out closest = null.
       }
-      return super.getClosest(key, val);
+      return closest;
     }
 
     /** {@inheritDoc} */
@@ -815,9 +830,19 @@ public class HStoreFile implements HConstants {
     @Override
     public synchronized boolean next(WritableComparable key, Writable val)
     throws IOException {
-      if (top && topFirstNextCall) {
-        topFirstNextCall = false;
-        return doFirstNextProcessing(key, val);
+      if (firstNextCall) {
+        firstNextCall = false;
+        if (this.top) {
+          // Seek to midkey.  Midkey may not exist in this file.  That should be
+          // fine.  Then we'll either be positioned at end or start of file.
+          WritableComparable nearest = getClosest(midkey, val);
+          // Now copy the mid key into the passed key.
+          if (nearest != null) {
+            Writables.copyWritable(nearest, key);
+            return true;
+          }
+          return false;
+        }
       }
       boolean result = super.next(key, val);
       if (!top && key.compareTo(midkey) >= 0) {
@@ -825,25 +850,12 @@ public class HStoreFile implements HConstants {
       }
       return result;
     }
-    
-    private boolean doFirstNextProcessing(WritableComparable key, Writable val)
-    throws IOException {
-      // Seek to midkey.  Midkey may not exist in this file.  That should be
-      // fine.  Then we'll either be positioned at end or start of file.
-      WritableComparable nearest = getClosest(midkey, val);
-      // Now copy the mid key into the passed key.
-      if (nearest != null) {
-        Writables.copyWritable(nearest, key);
-        return true;
-      }
-      return false;
-    }
 
     /** {@inheritDoc} */
     @Override
     public synchronized void reset() throws IOException {
       if (top) {
-        topFirstNextCall = true;
+        firstNextCall = true;
         seek(midkey);
         return;
       }