Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
 
 package org.apache.hadoop.hbase.io;
 
 
A facade for a org.apache.hadoop.hbase.io.hfile.HFile.Reader that serves up either the top or bottom half of a HFile where 'bottom' is the first half of the file containing the keys that sort lowest and 'top' is the second half of the file with keys that sort greater than those of the bottom half. The top includes the split files midkey, of the key that follows if it does not exist in the file.

This type works in tandem with the Reference type. This class is used reading while Reference is used writing.

This file is not splitable. Calls to midkey() return null.

 
 public class HalfStoreFileReader extends StoreFile.Reader {
   final Log LOG = LogFactory.getLog(HalfStoreFileReader.class);
   final boolean top;
   // This is the key we split around.  Its the first possible entry on a row:
   // i.e. empty column and a timestamp of LATEST_TIMESTAMP.
   protected final byte [] splitkey;
   
   private byte[] firstKey = null;
   
   private boolean firstKeySeeked = false;

  
Creates a half file reader for a normal hfile.

Parameters:
fs fileystem to read from
p path to hfile
cacheConf
r original reference file (contains top or bottom)
conf Configuration
Throws:
java.io.IOException
 
   public HalfStoreFileReader(final FileSystem fsfinal Path p,
       final CacheConfig cacheConffinal Reference rfinal Configuration conf)
       throws IOException {
     super(fspcacheConfconf);
     // This is not actual midkey for this half-file; its just border
     // around which we split top and bottom.  Have to look in files to find
     // actual last and first keys for bottom and top halves.  Half-files don't
     // have an actual midkey themselves. No midkey is how we indicate file is
     // not splittable.
     this. = r.getSplitKey();
     // Is it top or bottom half?
     this. = Reference.isTopFileRegion(r.getFileRegion());
   }

  
Creates a half file reader for a hfile referred to by an hfilelink.

Parameters:
fs fileystem to read from
p path to hfile
in FSDataInputStreamWrapper
size Full size of the hfile file
cacheConf
r original reference file (contains top or bottom)
conf Configuration
Throws:
java.io.IOException
 
   public HalfStoreFileReader(final FileSystem fsfinal Path pfinal FSDataInputStreamWrapper in,
       long sizefinal CacheConfig cacheConf,  final Reference rfinal Configuration conf)
       throws IOException {
    super(fspinsizecacheConfconf);
    // This is not actual midkey for this half-file; its just border
    // around which we split top and bottom.  Have to look in files to find
    // actual last and first keys for bottom and top halves.  Half-files don't
    // have an actual midkey themselves. No midkey is how we indicate file is
    // not splittable.
    this. = r.getSplitKey();
    // Is it top or bottom half?
    this. = Reference.isTopFileRegion(r.getFileRegion());
  }
  protected boolean isTop() {
    return this.;
  }
  public HFileScanner getScanner(final boolean cacheBlocks,
      final boolean preadfinal boolean isCompaction) {
    final HFileScanner s = super.getScanner(cacheBlockspreadisCompaction);
    return new HFileScanner() {
      final HFileScanner delegate = s;
      public boolean atEnd = false;
      public ByteBuffer getKey() {
        if (return null;
        return .getKey();
      }
      public String getKeyString() {
        if (return null;
        return .getKeyString();
      }
      public ByteBuffer getValue() {
        if (return null;
        return .getValue();
      }
      public String getValueString() {
        if (return null;
        return .getValueString();
      }
      public KeyValue getKeyValue() {
        if (return null;
        return .getKeyValue();
      }
      public boolean next() throws IOException {
        if (return false;
        boolean b = .next();
        if (!b) {
          return b;
        }
        // constrain the bottom.
        if (!) {
          ByteBuffer bb = getKey();
          if (getComparator().compareFlatKey(bb.array(), bb.arrayOffset(), bb.limit(),
              , 0, .) >= 0) {
             = true;
            return false;
          }
        }
        return true;
      }
      public boolean seekBefore(byte[] keythrows IOException {
        return seekBefore(key, 0, key.length);
      }
      public boolean seekBefore(byte [] keyint offsetint length)
      throws IOException {
        if () {
          byte[] fk = getFirstKey();
          // This will be null when the file is empty in which we can not seekBefore to any key
          if (fk == nullreturn false;
          if (getComparator().compareFlatKey(keyoffsetlengthfk, 0,
              fk.length) <= 0) {
            return false;
          }
        } else {
          // The equals sign isn't strictly necessary just here to be consistent with seekTo
          if (getComparator().compareFlatKey(keyoffsetlength, 0,
              .) >= 0) {
            boolean ret = this..seekBefore(, 0, .);
            if (ret) {
               = false;
            }
            return ret;
          }
        }
        boolean ret = this..seekBefore(keyoffsetlength);
        if (ret) {
           = false;
        }
        return ret;
      }
      public boolean seekTo() throws IOException {
        if () {
          int r = this..seekTo();
          if (r == .) {
            return true;
          }
          if (r < 0) {
            // midkey is < first key in file
            return this..seekTo();
          }
          if (r > 0) {
            return this..next();
          }
          return true;
        }
        boolean b = .seekTo();
        if (!b) {
          return b;
        }
        // Check key.
        ByteBuffer k = this..getKey();
        return this..getReader().getComparator().
          compareFlatKey(k.array(), k.arrayOffset(), k.limit(),
            , 0, .) < 0;
      }
      public int seekTo(byte[] keythrows IOException {
        return seekTo(key, 0, key.length);
      }
      public int seekTo(byte[] keyint offsetint lengththrows IOException {
        if () {
          if (getComparator().compareFlatKey(keyoffsetlength, 0,
              .) < 0) {
            return -1;
          }
        } else {
          if (getComparator().compareFlatKey(keyoffsetlength, 0,
              .) >= 0) {
            // we would place the scanner in the second half.
            // it might be an error to return false here ever...
            boolean res = .seekBefore(, 0, .);
            if (!res) {
              throw new IOException("Seeking for a key in bottom of file, but key exists in top of file, failed on seekBefore(midkey)");
            }
            return 1;
          }
        }
        return .seekTo(keyoffsetlength);
      }
      @Override
      public int reseekTo(byte[] keythrows IOException {
        return reseekTo(key, 0, key.length);
      }
      @Override
      public int reseekTo(byte[] keyint offsetint length)
      throws IOException {
        //This function is identical to the corresponding seekTo function except
        //that we call reseekTo (and not seekTo) on the delegate.
        if () {
          if (getComparator().compareFlatKey(keyoffsetlength, 0,
              .) < 0) {
            return -1;
          }
        } else {
          if (getComparator().compareFlatKey(keyoffsetlength, 0,
              .) >= 0) {
            // we would place the scanner in the second half.
            // it might be an error to return false here ever...
            boolean res = .seekBefore(, 0, .);
            if (!res) {
              throw new IOException("Seeking for a key in bottom of file, but" +
                  " key exists in top of file, failed on seekBefore(midkey)");
            }
            return 1;
          }
        }
        if () {
          // skip the 'reseek' and just return 1.
          return 1;
        }
        return .reseekTo(keyoffsetlength);
      }
      public org.apache.hadoop.hbase.io.hfile.HFile.Reader getReader() {
        return this..getReader();
      }
      public boolean isSeeked() {
        return this..isSeeked();
      }
    };
  }
  
  public boolean passesKeyRangeFilter(Scan scan) {
    return true;
  }
  
  public byte[] getLastKey() {
    if () {
      return super.getLastKey();
    }
    // Get a scanner that caches the block and that uses pread.
    HFileScanner scanner = getScanner(truetrue);
    try {
      if (scanner.seekBefore(this.)) {
        return Bytes.toBytes(scanner.getKey());
      }
    } catch (IOException e) {
      .warn("Failed seekBefore " + Bytes.toStringBinary(this.), e);
    }
    return null;
  }
  public byte[] midkey() throws IOException {
    // Returns null to indicate file is not splitable.
    return null;
  }
  
  public byte[] getFirstKey() {
    if (!) {
      HFileScanner scanner = getScanner(truetruefalse);
      try {
        if (scanner.seekTo()) {
          this. = Bytes.toBytes(scanner.getKey());
        }
         = true;
      } catch (IOException e) {
        .warn("Failed seekTo first KV in the file"e);
      }
    }
    return this.;
  }
  public long getEntries() {
    // Estimate the number of entries as half the original file; this may be wildly inaccurate.
    return super.getEntries() / 2;
  }
  public long getFilterEntries() {
    // Estimate the number of entries as half the original file; this may be wildly inaccurate.
    return super.getFilterEntries() / 2;
  }
New to GrepCode? Check out our FAQ X