View Javadoc

1   /**
2    *
3    * Licensed to the Apache Software Foundation (ASF) under one
4    * or more contributor license agreements.  See the NOTICE file
5    * distributed with this work for additional information
6    * regarding copyright ownership.  The ASF licenses this file
7    * to you under the Apache License, Version 2.0 (the
8    * "License"); you may not use this file except in compliance
9    * with the License.  You may obtain a copy of the License at
10   *
11   *     http://www.apache.org/licenses/LICENSE-2.0
12   *
13   * Unless required by applicable law or agreed to in writing, software
14   * distributed under the License is distributed on an "AS IS" BASIS,
15   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16   * See the License for the specific language governing permissions and
17   * limitations under the License.
18   */
19  package org.apache.hadoop.hbase.mapreduce;
20  
21  import java.io.DataInput;
22  import java.io.DataOutput;
23  import java.io.IOException;
24  import java.util.Arrays;
25  
26  import org.apache.commons.logging.Log;
27  import org.apache.commons.logging.LogFactory;
28  import org.apache.hadoop.classification.InterfaceAudience;
29  import org.apache.hadoop.classification.InterfaceStability;
30  import org.apache.hadoop.hbase.TableName;
31  import org.apache.hadoop.hbase.HConstants;
32  import org.apache.hadoop.hbase.client.Scan;
33  import org.apache.hadoop.hbase.util.Bytes;
34  import org.apache.hadoop.io.Writable;
35  import org.apache.hadoop.io.WritableUtils;
36  import org.apache.hadoop.mapreduce.InputSplit;
37  
38  /**
39   * A table split corresponds to a key range (low, high) and an optional scanner.
40   * All references to row below refer to the key of the row.
41   */
42  @InterfaceAudience.Public
43  @InterfaceStability.Evolving
44  public class TableSplit extends InputSplit
45  implements Writable, Comparable<TableSplit> {
46    public static final Log LOG = LogFactory.getLog(TableSplit.class);
47    
48    // should be < 0 (@see #readFields(DataInput))
49    // version 1 supports Scan data member
50    enum Version {
51      UNVERSIONED(0),
52      // Initial number we put on TableSplit when we introduced versioning.
53      INITIAL(-1);
54  
55      final int code;
56      static final Version[] byCode;
57      static {
58        byCode = Version.values();
59        for (int i = 0; i < byCode.length; i++) {
60          if (byCode[i].code != -1 * i) {
61            throw new AssertionError("Values in this enum should be descending by one");
62          }
63        }
64      }
65  
66      Version(int code) {
67        this.code = code;
68      }
69  
70      boolean atLeast(Version other) {
71        return code <= other.code;
72      }
73  
74      static Version fromCode(int code) {
75        return byCode[code * -1];
76      }
77    }
78    
79    private static final Version VERSION = Version.INITIAL;
80    private TableName tableName;
81    private byte [] startRow;
82    private byte [] endRow;
83    private String regionLocation;
84    private String scan = ""; // stores the serialized form of the Scan
85  
86    /** Default constructor. */
87    public TableSplit() {
88      this((TableName)null, null, HConstants.EMPTY_BYTE_ARRAY,
89        HConstants.EMPTY_BYTE_ARRAY, "");
90    }
91  
92    /**
93     * @deprecated Since 0.96.0; use {@link TableSplit#TableSplit(TableName, byte[], byte[], String)}
94     */
95    @Deprecated
96    public TableSplit(final byte [] tableName, Scan scan, byte [] startRow, byte [] endRow,
97        final String location) {
98      this(TableName.valueOf(tableName), scan, startRow, endRow, location);
99    }
100 
101   /**
102    * Creates a new instance while assigning all variables.
103    *
104    * @param tableName  The name of the current table.
105    * @param scan The scan associated with this split.
106    * @param startRow  The start row of the split.
107    * @param endRow  The end row of the split.
108    * @param location  The location of the region.
109    */
110   public TableSplit(TableName tableName, Scan scan, byte [] startRow, byte [] endRow,
111       final String location) {
112     this.tableName = tableName;
113     try {
114       this.scan =
115         (null == scan) ? "" : TableMapReduceUtil.convertScanToString(scan);
116     } catch (IOException e) {
117       LOG.warn("Failed to convert Scan to String", e);
118     }
119     this.startRow = startRow;
120     this.endRow = endRow;
121     this.regionLocation = location;
122   }
123 
124   /**
125    * @deprecated Since 0.96.0; use {@link TableSplit#TableSplit(TableName, byte[], byte[], String)}
126    */
127   @Deprecated
128   public TableSplit(final byte [] tableName, byte[] startRow, byte[] endRow,
129       final String location) {
130     this(TableName.valueOf(tableName), startRow, endRow, location);
131   }
132 
133   /**
134    * Creates a new instance without a scanner.
135    *
136    * @param tableName The name of the current table.
137    * @param startRow The start row of the split.
138    * @param endRow The end row of the split.
139    * @param location The location of the region.
140    */
141   public TableSplit(TableName tableName, byte[] startRow, byte[] endRow,
142       final String location) {
143     this(tableName, null, startRow, endRow, location);
144   }
145 
146   /**
147    * Returns a Scan object from the stored string representation.
148    *
149    * @return Returns a Scan object based on the stored scanner.
150    * @throws IOException
151    */
152   public Scan getScan() throws IOException {
153     return TableMapReduceUtil.convertStringToScan(this.scan);
154   }
155 
156   /**
157    * Returns the table name converted to a byte array.
158    * @see #getTable()
159    * @return The table name.
160    */
161   public byte [] getTableName() {
162     return tableName.getName();
163   }
164 
165   /**
166    * Returns the table name.
167    *
168    * @return The table name.
169    */
170   public TableName getTable() {
171     // It is ugly that usually to get a TableName, the method is called getTableName.  We can't do
172     // that in here though because there was an existing getTableName in place already since
173     // deprecated.
174     return tableName;
175   }
176 
177   /**
178    * Returns the start row.
179    *
180    * @return The start row.
181    */
182   public byte [] getStartRow() {
183     return startRow;
184   }
185 
186   /**
187    * Returns the end row.
188    *
189    * @return The end row.
190    */
191   public byte [] getEndRow() {
192     return endRow;
193   }
194 
195   /**
196    * Returns the region location.
197    *
198    * @return The region's location.
199    */
200   public String getRegionLocation() {
201     return regionLocation;
202   }
203 
204   /**
205    * Returns the region's location as an array.
206    *
207    * @return The array containing the region location.
208    * @see org.apache.hadoop.mapreduce.InputSplit#getLocations()
209    */
210   @Override
211   public String[] getLocations() {
212     return new String[] {regionLocation};
213   }
214 
215   /**
216    * Returns the length of the split.
217    *
218    * @return The length of the split.
219    * @see org.apache.hadoop.mapreduce.InputSplit#getLength()
220    */
221   @Override
222   public long getLength() {
223     // Not clear how to obtain this... seems to be used only for sorting splits
224     return 0;
225   }
226 
227   /**
228    * Reads the values of each field.
229    *
230    * @param in  The input to read from.
231    * @throws IOException When reading the input fails.
232    */
233   @Override
234   public void readFields(DataInput in) throws IOException {
235     Version version = Version.UNVERSIONED;
236     // TableSplit was not versioned in the beginning.
237     // In order to introduce it now, we make use of the fact
238     // that tableName was written with Bytes.writeByteArray,
239     // which encodes the array length as a vint which is >= 0.
240     // Hence if the vint is >= 0 we have an old version and the vint
241     // encodes the length of tableName.
242     // If < 0 we just read the version and the next vint is the length.
243     // @see Bytes#readByteArray(DataInput)
244     int len = WritableUtils.readVInt(in);
245     if (len < 0) {
246       // what we just read was the version
247       version = Version.fromCode(len);
248       len = WritableUtils.readVInt(in);
249     }
250     byte[] tableNameBytes = new byte[len];
251     in.readFully(tableNameBytes);
252     tableName = TableName.valueOf(tableNameBytes);
253     startRow = Bytes.readByteArray(in);
254     endRow = Bytes.readByteArray(in);
255     regionLocation = Bytes.toString(Bytes.readByteArray(in));
256     if (version.atLeast(Version.INITIAL)) {
257       scan = Bytes.toString(Bytes.readByteArray(in));
258     }
259   }
260 
261   /**
262    * Writes the field values to the output.
263    *
264    * @param out  The output to write to.
265    * @throws IOException When writing the values to the output fails.
266    */
267   @Override
268   public void write(DataOutput out) throws IOException {
269     WritableUtils.writeVInt(out, VERSION.code);
270     Bytes.writeByteArray(out, tableName.getName());
271     Bytes.writeByteArray(out, startRow);
272     Bytes.writeByteArray(out, endRow);
273     Bytes.writeByteArray(out, Bytes.toBytes(regionLocation));
274     Bytes.writeByteArray(out, Bytes.toBytes(scan));
275   }
276 
277   /**
278    * Returns the details about this instance as a string.
279    *
280    * @return The values of this instance as a string.
281    * @see java.lang.Object#toString()
282    */
283   @Override
284   public String toString() {
285     return regionLocation + ":" +
286       Bytes.toStringBinary(startRow) + "," + Bytes.toStringBinary(endRow);
287   }
288 
289   /**
290    * Compares this split against the given one.
291    *
292    * @param split  The split to compare to.
293    * @return The result of the comparison.
294    * @see java.lang.Comparable#compareTo(java.lang.Object)
295    */
296   @Override
297   public int compareTo(TableSplit split) {
298     // If The table name of the two splits is the same then compare start row
299     // otherwise compare based on table names
300     int tableNameComparison =
301         getTable().compareTo(split.getTable());
302     return tableNameComparison != 0 ? tableNameComparison : Bytes.compareTo(
303         getStartRow(), split.getStartRow());
304   }
305 
306   @Override
307   public boolean equals(Object o) {
308     if (o == null || !(o instanceof TableSplit)) {
309       return false;
310     }
311     return tableName.equals(((TableSplit)o).tableName) &&
312       Bytes.equals(startRow, ((TableSplit)o).startRow) &&
313       Bytes.equals(endRow, ((TableSplit)o).endRow) &&
314       regionLocation.equals(((TableSplit)o).regionLocation);
315   }
316 
317     @Override
318     public int hashCode() {
319         int result = tableName != null ? tableName.hashCode() : 0;
320         result = 31 * result + (scan != null ? scan.hashCode() : 0);
321         result = 31 * result + (startRow != null ? Arrays.hashCode(startRow) : 0);
322         result = 31 * result + (endRow != null ? Arrays.hashCode(endRow) : 0);
323         result = 31 * result + (regionLocation != null ? regionLocation.hashCode() : 0);
324         return result;
325     }
326 }