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.pig.backend.hadoop.hbase;
 
 import java.util.List;
 
 import  org.apache.hadoop.hbase.mapreduce.TableInputFormat;
 import  org.apache.hadoop.hbase.mapreduce.TableRecordReader;
 import  org.apache.hadoop.hbase.mapreduce.TableSplit;
 
 public class HBaseTableInputFormat extends TableInputFormat {
     private static final Log LOG = LogFactory.getLog(HBaseTableInputFormat.class);
 
     protected final byte[] gt_;
     protected final byte[] gte_;
     protected final byte[] lt_;
     protected final byte[] lte_;
 
     public HBaseTableInputFormat() {
         this(-1, nullnullnullnull);
     }
 
     protected HBaseTableInputFormat(long limitbyte[] gtbyte[] gtebyte[] ltbyte[] lte) {
         super();
         setTableRecordReader(new HBaseTableRecordReader(limit));
          = gt;
          = gte;
          = lt;
          = lte;
     }
 
     public static class HBaseTableIFBuilder {
         protected byte[] gt_;
         protected byte[] gte_;
         protected byte[] lt_;
         protected byte[] lte_;
         protected long limit_;
         protected Configuration conf_;
 
         public HBaseTableIFBuilder withGt(byte[] gt) {  = gtreturn this; }
         public HBaseTableIFBuilder withGte(byte[] gte) {  = gtereturn this; }
         public HBaseTableIFBuilder withLt(byte[] lt) {  = ltreturn this; }
         public HBaseTableIFBuilder withLte(byte[] lte) {  = ltereturn this; }
         public HBaseTableIFBuilder withLimit(long limit) {  = limitreturn this; }
         public HBaseTableIFBuilder withConf(Configuration conf) {  = confreturn this; }
 
         public HBaseTableInputFormat build() {
             HBaseTableInputFormat inputFormat = new HBaseTableInputFormat();
             if ( != nullinputFormat.setConf();
             return inputFormat;
         }
 
     }
 
     @Override
     throws IOException {
         List<InputSplitsplits = super.getSplits(context);
         ListIterator<InputSplitsplitIter = splits.listIterator();
         while (splitIter.hasNext()) {
             TableSplit split = (TableSplit) splitIter.next();
             byte[] startKey = split.getStartRow();
             byte[] endKey = split.getEndRow();
             // Skip if the region doesn't satisfy configured options.
             if ((skipRegion(.startKey)) ||
                     (skipRegion(.endKey)) ||
                     (skipRegion(.endKey)) ||
                     (skipRegion(.startKey)) )  {
                 splitIter.remove();
             }
        }
        return splits;
    }
    private boolean skipRegion(CompareOp opbyte[] keybyte[] option ) {
        if (key.length == 0 || option == null
            return false;
        BinaryComparator comp = new BinaryComparator(option);
        RowFilter rowFilter = new RowFilter(opcomp);
        return rowFilter.filterRowKey(key, 0, key.length);
    }
    protected class HBaseTableRecordReader extends TableRecordReader {
        private long recordsSeen = 0;
        private final long limit_;
        private byte[] startRow_;
        private byte[] endRow_;
        private transient byte[] currRow_;
        private BigInteger bigStart_;
        private BigInteger bigEnd_;
        private BigDecimal bigRange_;
        private transient float progressSoFar_ = 0;
        public HBaseTableRecordReader(long limit) {
             = limit;
        }
        @Override
        public void setScan(Scan scan) {
            super.setScan(scan);
             = scan.getStartRow();
             = scan.getStopRow();
            byte[] startPadded;
            byte[] endPadded;
            if (. < .) {
                startPadded = Bytes.padTail(. - .);
                endPadded = ;
            } else if (. < .) {
                startPadded = ;
                endPadded = Bytes.padTail(. - .);
            } else {
                startPadded = ;
                endPadded = ;
            }
             = ;
            byte [] prependHeader = {1, 0};
             = new BigInteger(Bytes.add(prependHeaderstartPadded));
             = new BigInteger(Bytes.add(prependHeaderendPadded));
             = new BigDecimal(.subtract());
            .info("setScan with ranges: " +  + " - " +  + " ( " +  + ")");
        }
        @Override
        public boolean nextKeyValue() throws IOExceptionInterruptedException {
            if ( > 0 && ++ > ) {
                return false;
            }
            boolean hasMore = super.nextKeyValue();
            if (hasMore) {
                 = getCurrentKey().get();
            }
            return hasMore;
        }
        @Override
        public float getProgress() {
            if ( == null || . == 0 || . == 0 ||  == .) {
                return 0;
            }
            byte[] lastPadded = ;
            if (. < .) {
                lastPadded = Bytes.padTail(. - .);
            }
            if (. < .) {
                lastPadded = Bytes.padTail(. - .);
            }
            byte [] prependHeader = {1, 0};
            BigInteger bigLastRow = new BigInteger(Bytes.add(prependHeaderlastPadded));
            if (bigLastRow.compareTo() > 0) {
                return ;
            }
            BigDecimal processed = new BigDecimal(bigLastRow.subtract());
            try {
                BigDecimal progress = processed.setScale(3).divide(.);
                 = progress.floatValue();
                return ;
            } catch (java.lang.ArithmeticException e) {
                return 0;
            }            
        }
    }
New to GrepCode? Check out our FAQ X