View Javadoc

1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *     http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing, software
13   * distributed under the License is distributed on an "AS IS" BASIS,
14   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15   * See the License for the specific language governing permissions and
16   * limitations under the License.
17   */
18  
19  package org.apache.hadoop.hbase.codec.prefixtree;
20  
21  import java.io.DataInputStream;
22  import java.io.DataOutputStream;
23  import java.io.IOException;
24  import java.nio.ByteBuffer;
25  
26  import org.apache.hadoop.hbase.classification.InterfaceAudience;
27  import org.apache.hadoop.hbase.Cell;
28  import org.apache.hadoop.hbase.CellComparator;
29  import org.apache.hadoop.hbase.KeyValue;
30  import org.apache.hadoop.hbase.CellComparator.MetaCellComparator;
31  import org.apache.hadoop.hbase.KeyValueUtil;
32  import org.apache.hadoop.hbase.codec.prefixtree.decode.DecoderFactory;
33  import org.apache.hadoop.hbase.codec.prefixtree.decode.PrefixTreeArraySearcher;
34  import org.apache.hadoop.hbase.codec.prefixtree.encode.EncoderFactory;
35  import org.apache.hadoop.hbase.codec.prefixtree.encode.PrefixTreeEncoder;
36  import org.apache.hadoop.hbase.codec.prefixtree.scanner.CellSearcher;
37  import org.apache.hadoop.hbase.io.encoding.DataBlockEncoder;
38  import org.apache.hadoop.hbase.io.encoding.DataBlockEncoding;
39  import org.apache.hadoop.hbase.io.encoding.EncodingState;
40  import org.apache.hadoop.hbase.io.encoding.HFileBlockDecodingContext;
41  import org.apache.hadoop.hbase.io.encoding.HFileBlockDefaultDecodingContext;
42  import org.apache.hadoop.hbase.io.encoding.HFileBlockDefaultEncodingContext;
43  import org.apache.hadoop.hbase.io.encoding.HFileBlockEncodingContext;
44  import org.apache.hadoop.hbase.io.hfile.BlockType;
45  import org.apache.hadoop.hbase.io.hfile.HFileContext;
46  import org.apache.hadoop.hbase.util.ByteBufferUtils;
47  import org.apache.hadoop.io.WritableUtils;
48  
49  /**
50   * <p>
51   * This class is created via reflection in DataBlockEncoding enum. Update the enum if class name or
52   * package changes.
53   * </p>
54   * PrefixTreeDataBlockEncoder implementation of DataBlockEncoder. This is the primary entry point
55   * for PrefixTree encoding and decoding. Encoding is delegated to instances of
56   * {@link PrefixTreeEncoder}, and decoding is delegated to instances of
57   * {@link org.apache.hadoop.hbase.codec.prefixtree.scanner.CellSearcher}. Encoder and decoder instances are
58   * created and recycled by static PtEncoderFactory and PtDecoderFactory.
59   */
60  @InterfaceAudience.Private
61  public class PrefixTreeCodec implements DataBlockEncoder {
62  
63    /**
64     * no-arg constructor for reflection
65     */
66    public PrefixTreeCodec() {
67    }
68  
69    @Override
70    public ByteBuffer decodeKeyValues(DataInputStream source, HFileBlockDecodingContext decodingCtx)
71        throws IOException {
72      return decodeKeyValues(source, 0, 0, decodingCtx);
73    }
74  
75  
76    /**
77     * I don't think this method is called during normal HBase operation, so efficiency is not
78     * important.
79     */
80    public ByteBuffer decodeKeyValues(DataInputStream source, int allocateHeaderLength,
81        int skipLastBytes, HFileBlockDecodingContext decodingCtx) throws IOException {
82      ByteBuffer sourceAsBuffer = ByteBufferUtils.drainInputStreamToBuffer(source);// waste
83      sourceAsBuffer.mark();
84      PrefixTreeBlockMeta blockMeta = new PrefixTreeBlockMeta(sourceAsBuffer);
85      sourceAsBuffer.rewind();
86      int numV1BytesWithHeader = allocateHeaderLength + blockMeta.getNumKeyValueBytes();
87      byte[] keyValueBytesWithHeader = new byte[numV1BytesWithHeader];
88      ByteBuffer result = ByteBuffer.wrap(keyValueBytesWithHeader);
89      result.rewind();
90      CellSearcher searcher = null;
91      try {
92        boolean includesMvcc = decodingCtx.getHFileContext().isIncludesMvcc();
93        searcher = DecoderFactory.checkOut(sourceAsBuffer, includesMvcc);
94        while (searcher.advance()) {
95          KeyValue currentCell = KeyValueUtil.copyToNewKeyValue(searcher.current());
96          // needs to be modified for DirectByteBuffers. no existing methods to
97          // write VLongs to byte[]
98          int offset = result.arrayOffset() + result.position();
99          System.arraycopy(currentCell.getBuffer(), currentCell.getOffset(), result.array(), offset,
100             currentCell.getLength());
101         int keyValueLength = KeyValueUtil.length(currentCell);
102         ByteBufferUtils.skip(result, keyValueLength);
103         offset += keyValueLength;
104         if (includesMvcc) {
105           ByteBufferUtils.writeVLong(result, currentCell.getMvccVersion());
106         }
107       }
108       result.position(result.limit());//make it appear as if we were appending
109       return result;
110     } finally {
111       DecoderFactory.checkIn(searcher);
112     }
113   }
114 
115 
116   @Override
117   public ByteBuffer getFirstKeyInBlock(ByteBuffer block) {
118     block.rewind();
119     PrefixTreeArraySearcher searcher = null;
120     try {
121       // should i includeMemstoreTS (second argument)?  i think PrefixKeyDeltaEncoder is, so i will
122       searcher = DecoderFactory.checkOut(block, true);
123       if (!searcher.positionAtFirstCell()) {
124         return null;
125       }
126       return KeyValueUtil.copyKeyToNewByteBuffer(searcher.current());
127     } finally {
128       DecoderFactory.checkIn(searcher);
129     }
130   }
131 
132   @Override
133   public HFileBlockEncodingContext newDataBlockEncodingContext(
134       DataBlockEncoding encoding, byte[] header, HFileContext meta) {
135     if(DataBlockEncoding.PREFIX_TREE != encoding){
136       //i'm not sure why encoding is in the interface.  Each encoder implementation should probably
137       //know it's encoding type
138       throw new IllegalArgumentException("only DataBlockEncoding.PREFIX_TREE supported");
139     }
140     return new HFileBlockDefaultEncodingContext(encoding, header, meta);
141   }
142 
143   @Override
144   public HFileBlockDecodingContext newDataBlockDecodingContext(HFileContext meta) {
145     return new HFileBlockDefaultDecodingContext(meta);
146   }
147 
148   /**
149    * Is this the correct handling of an illegal comparator?  How to prevent that from getting all
150    * the way to this point.
151    */
152   @Override
153   public EncodedSeeker createSeeker(CellComparator comparator,
154       HFileBlockDecodingContext decodingCtx) {
155     if (comparator instanceof MetaCellComparator) {
156       throw new IllegalArgumentException(
157           "DataBlockEncoding.PREFIX_TREE not compatible with hbase:meta " + "table");
158     }
159 
160     return new PrefixTreeSeeker(decodingCtx.getHFileContext().isIncludesMvcc());
161   }
162 
163   @Override
164   public int encode(Cell cell, HFileBlockEncodingContext encodingCtx, DataOutputStream out)
165       throws IOException {
166     PrefixTreeEncodingState state = (PrefixTreeEncodingState) encodingCtx.getEncodingState();
167     PrefixTreeEncoder builder = state.builder;
168     builder.write(cell);
169     int size = KeyValueUtil.length(cell);
170     if (encodingCtx.getHFileContext().isIncludesMvcc()) {
171       size += WritableUtils.getVIntSize(cell.getSequenceId());
172     }
173     return size;
174   }
175 
176   private static class PrefixTreeEncodingState extends EncodingState {
177     PrefixTreeEncoder builder = null;
178   }
179 
180   @Override
181   public void startBlockEncoding(HFileBlockEncodingContext blkEncodingCtx, DataOutputStream out)
182       throws IOException {
183     if (blkEncodingCtx.getClass() != HFileBlockDefaultEncodingContext.class) {
184       throw new IOException(this.getClass().getName() + " only accepts "
185           + HFileBlockDefaultEncodingContext.class.getName() + " as the " + "encoding context.");
186     }
187 
188     HFileBlockDefaultEncodingContext encodingCtx = 
189         (HFileBlockDefaultEncodingContext) blkEncodingCtx;
190     encodingCtx.prepareEncoding(out);
191 
192     PrefixTreeEncoder builder = EncoderFactory.checkOut(out, encodingCtx.getHFileContext()
193         .isIncludesMvcc());
194     PrefixTreeEncodingState state = new PrefixTreeEncodingState();
195     state.builder = builder;
196     blkEncodingCtx.setEncodingState(state);
197   }
198 
199   @Override
200   public void endBlockEncoding(HFileBlockEncodingContext encodingCtx, DataOutputStream out,
201       byte[] uncompressedBytesWithHeader) throws IOException {
202     PrefixTreeEncodingState state = (PrefixTreeEncodingState) encodingCtx.getEncodingState();
203     PrefixTreeEncoder builder = state.builder;
204     builder.flush();
205     EncoderFactory.checkIn(builder);
206     // do i need to check this, or will it always be DataBlockEncoding.PREFIX_TREE?
207     if (encodingCtx.getDataBlockEncoding() != DataBlockEncoding.NONE) {
208       encodingCtx.postEncoding(BlockType.ENCODED_DATA);
209     } else {
210       encodingCtx.postEncoding(BlockType.DATA);
211     }
212   }
213 }