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.classification.InterfaceAudience;
27  import org.apache.hadoop.hbase.KeyValue;
28  import org.apache.hadoop.hbase.KeyValue.KVComparator;
29  import org.apache.hadoop.hbase.KeyValue.MetaComparator;
30  import org.apache.hadoop.hbase.KeyValue.RawBytesComparator;
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.compress.Compression.Algorithm;
38  import org.apache.hadoop.hbase.io.encoding.DataBlockEncoder;
39  import org.apache.hadoop.hbase.io.encoding.DataBlockEncoding;
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.util.ByteBufferUtils;
46  import org.apache.hadoop.io.RawComparator;
47  
48  /**
49   * This class is created via reflection in DataBlockEncoding enum. Update the enum if class name or
50   * package changes.
51   * <p/>
52   * PrefixTreeDataBlockEncoder implementation of DataBlockEncoder. This is the primary entry point
53   * for PrefixTree encoding and decoding. Encoding is delegated to instances of
54   * {@link PrefixTreeEncoder}, and decoding is delegated to instances of
55   * {@link org.apache.hadoop.hbase.codec.prefixtree.scanner.CellSearcher}. Encoder and decoder instances are
56   * created and recycled by static PtEncoderFactory and PtDecoderFactory.
57   */
58  @InterfaceAudience.Private
59  public class PrefixTreeCodec implements DataBlockEncoder{
60  
61    /**
62     * no-arg constructor for reflection
63     */
64    public PrefixTreeCodec() {
65    }
66  
67    /**
68     * Copied from BufferedDataBlockEncoder. Almost definitely can be improved, but i'm not familiar
69     * enough with the concept of the HFileBlockEncodingContext.
70     */
71    @Override
72    public void encodeKeyValues(ByteBuffer in, boolean includesMvccVersion,
73        HFileBlockEncodingContext blkEncodingCtx) throws IOException {
74      if (blkEncodingCtx.getClass() != HFileBlockDefaultEncodingContext.class) {
75        throw new IOException(this.getClass().getName() + " only accepts "
76            + HFileBlockDefaultEncodingContext.class.getName() + " as the " + "encoding context.");
77      }
78  
79      HFileBlockDefaultEncodingContext encodingCtx
80          = (HFileBlockDefaultEncodingContext) blkEncodingCtx;
81      encodingCtx.prepareEncoding();
82      DataOutputStream dataOut = encodingCtx.getOutputStreamForEncoder();
83      internalEncodeKeyValues(dataOut, in, includesMvccVersion);
84  
85      //do i need to check this, or will it always be DataBlockEncoding.PREFIX_TREE?
86      if (encodingCtx.getDataBlockEncoding() != DataBlockEncoding.NONE) {
87        encodingCtx.postEncoding(BlockType.ENCODED_DATA);
88      } else {
89        encodingCtx.postEncoding(BlockType.DATA);
90      }
91    }
92  
93    private void internalEncodeKeyValues(DataOutputStream encodedOutputStream,
94        ByteBuffer rawKeyValues, boolean includesMvccVersion) throws IOException {
95      rawKeyValues.rewind();
96      PrefixTreeEncoder builder = EncoderFactory.checkOut(encodedOutputStream, includesMvccVersion);
97  
98      try{
99        KeyValue kv;
100       while ((kv = KeyValueUtil.nextShallowCopy(rawKeyValues, includesMvccVersion)) != null) {
101         builder.write(kv);
102       }
103       builder.flush();
104     }finally{
105       EncoderFactory.checkIn(builder);
106     }
107   }
108 
109 
110   @Override
111   public ByteBuffer decodeKeyValues(DataInputStream source, boolean includesMvccVersion)
112       throws IOException {
113     return decodeKeyValues(source, 0, 0, includesMvccVersion);
114   }
115 
116 
117   /**
118    * I don't think this method is called during normal HBase operation, so efficiency is not
119    * important.
120    */
121   @Override
122   public ByteBuffer decodeKeyValues(DataInputStream source, int allocateHeaderLength,
123       int skipLastBytes, boolean includesMvccVersion) throws IOException {
124     ByteBuffer sourceAsBuffer = ByteBufferUtils.drainInputStreamToBuffer(source);// waste
125     sourceAsBuffer.mark();
126     PrefixTreeBlockMeta blockMeta = new PrefixTreeBlockMeta(sourceAsBuffer);
127     sourceAsBuffer.rewind();
128     int numV1BytesWithHeader = allocateHeaderLength + blockMeta.getNumKeyValueBytes();
129     byte[] keyValueBytesWithHeader = new byte[numV1BytesWithHeader];
130     ByteBuffer result = ByteBuffer.wrap(keyValueBytesWithHeader);
131     result.rewind();
132     CellSearcher searcher = null;
133     try {
134       searcher = DecoderFactory.checkOut(sourceAsBuffer, includesMvccVersion);
135       while (searcher.advance()) {
136         KeyValue currentCell = KeyValueUtil.copyToNewKeyValue(searcher.current());
137         // needs to be modified for DirectByteBuffers. no existing methods to
138         // write VLongs to byte[]
139         int offset = result.arrayOffset() + result.position();
140         KeyValueUtil.appendToByteArray(currentCell, result.array(), offset);
141         int keyValueLength = KeyValueUtil.length(currentCell);
142         ByteBufferUtils.skip(result, keyValueLength);
143         offset += keyValueLength;
144         if (includesMvccVersion) {
145           ByteBufferUtils.writeVLong(result, currentCell.getMvccVersion());
146         }
147       }
148       result.position(result.limit());//make it appear as if we were appending
149       return result;
150     } finally {
151       DecoderFactory.checkIn(searcher);
152     }
153   }
154 
155 
156   @Override
157   public ByteBuffer getFirstKeyInBlock(ByteBuffer block) {
158     block.rewind();
159     PrefixTreeArraySearcher searcher = null;
160     try {
161       //should i includeMemstoreTS (second argument)?  i think PrefixKeyDeltaEncoder is, so i will
162       searcher = DecoderFactory.checkOut(block, true);
163       if (!searcher.positionAtFirstCell()) {
164         return null;
165       }
166       return KeyValueUtil.copyKeyToNewByteBuffer(searcher.current());
167     } finally {
168       DecoderFactory.checkIn(searcher);
169     }
170   }
171 
172   @Override
173   public HFileBlockEncodingContext newDataBlockEncodingContext(Algorithm compressionAlgorithm,
174       DataBlockEncoding encoding, byte[] header) {
175     if(DataBlockEncoding.PREFIX_TREE != encoding){
176       //i'm not sure why encoding is in the interface.  Each encoder implementation should probably
177       //know it's encoding type
178       throw new IllegalArgumentException("only DataBlockEncoding.PREFIX_TREE supported");
179     }
180     return new HFileBlockDefaultEncodingContext(compressionAlgorithm, encoding, header);
181   }
182 
183   @Override
184   public HFileBlockDecodingContext newDataBlockDecodingContext(Algorithm compressionAlgorithm) {
185     return new HFileBlockDefaultDecodingContext(compressionAlgorithm);
186   }
187 
188   /**
189    * Is this the correct handling of an illegal comparator?  How to prevent that from getting all
190    * the way to this point.
191    */
192   @Override
193   public EncodedSeeker createSeeker(KVComparator comparator, boolean includesMvccVersion) {
194     if (comparator instanceof RawBytesComparator){
195       throw new IllegalArgumentException("comparator must be KeyValue.KeyComparator");
196     } else if (comparator instanceof MetaComparator){
197       throw new IllegalArgumentException("DataBlockEncoding.PREFIX_TREE not compatible with hbase:meta "
198           +"table");
199     }
200 
201     return new PrefixTreeSeeker(includesMvccVersion);
202   }
203 
204 }