1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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
40
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
49
50 enum Version {
51 UNVERSIONED(0),
52
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 = "";
85
86
87 public TableSplit() {
88 this(null, null, HConstants.EMPTY_BYTE_ARRAY,
89 HConstants.EMPTY_BYTE_ARRAY, "");
90 }
91
92
93
94
95
96
97
98
99
100
101 public TableSplit(TableName tableName, Scan scan, byte [] startRow, byte [] endRow,
102 final String location) {
103 this.tableName = tableName;
104 try {
105 this.scan =
106 (null == scan) ? "" : TableMapReduceUtil.convertScanToString(scan);
107 } catch (IOException e) {
108 LOG.warn("Failed to convert Scan to String", e);
109 }
110 this.startRow = startRow;
111 this.endRow = endRow;
112 this.regionLocation = location;
113 }
114
115
116
117
118
119
120
121
122
123 public TableSplit(TableName tableName, byte[] startRow, byte[] endRow,
124 final String location) {
125 this(tableName, null, startRow, endRow, location);
126 }
127
128
129
130
131
132
133
134 public Scan getScan() throws IOException {
135 return TableMapReduceUtil.convertStringToScan(this.scan);
136 }
137
138
139
140
141
142
143 public TableName getTableName() {
144 return tableName;
145 }
146
147
148
149
150
151
152 public byte [] getStartRow() {
153 return startRow;
154 }
155
156
157
158
159
160
161 public byte [] getEndRow() {
162 return endRow;
163 }
164
165
166
167
168
169
170 public String getRegionLocation() {
171 return regionLocation;
172 }
173
174
175
176
177
178
179
180 @Override
181 public String[] getLocations() {
182 return new String[] {regionLocation};
183 }
184
185
186
187
188
189
190
191 @Override
192 public long getLength() {
193
194 return 0;
195 }
196
197
198
199
200
201
202
203 @Override
204 public void readFields(DataInput in) throws IOException {
205 Version version = Version.UNVERSIONED;
206
207
208
209
210
211
212
213
214 int len = WritableUtils.readVInt(in);
215 if (len < 0) {
216
217 version = Version.fromCode(len);
218 len = WritableUtils.readVInt(in);
219 }
220 byte[] tableNameBytes = new byte[len];
221 in.readFully(tableNameBytes);
222 tableName = TableName.valueOf(tableNameBytes);
223 startRow = Bytes.readByteArray(in);
224 endRow = Bytes.readByteArray(in);
225 regionLocation = Bytes.toString(Bytes.readByteArray(in));
226 if (version.atLeast(Version.INITIAL)) {
227 scan = Bytes.toString(Bytes.readByteArray(in));
228 }
229 }
230
231
232
233
234
235
236
237 @Override
238 public void write(DataOutput out) throws IOException {
239 WritableUtils.writeVInt(out, VERSION.code);
240 Bytes.writeByteArray(out, tableName.getName());
241 Bytes.writeByteArray(out, startRow);
242 Bytes.writeByteArray(out, endRow);
243 Bytes.writeByteArray(out, Bytes.toBytes(regionLocation));
244 Bytes.writeByteArray(out, Bytes.toBytes(scan));
245 }
246
247
248
249
250
251
252
253 @Override
254 public String toString() {
255 return regionLocation + ":" +
256 Bytes.toStringBinary(startRow) + "," + Bytes.toStringBinary(endRow);
257 }
258
259
260
261
262
263
264
265
266 @Override
267 public int compareTo(TableSplit split) {
268
269
270 int tableNameComparison =
271 getTableName().compareTo(split.getTableName());
272 return tableNameComparison != 0 ? tableNameComparison : Bytes.compareTo(
273 getStartRow(), split.getStartRow());
274 }
275
276 @Override
277 public boolean equals(Object o) {
278 if (o == null || !(o instanceof TableSplit)) {
279 return false;
280 }
281 return tableName.equals(((TableSplit)o).tableName) &&
282 Bytes.equals(startRow, ((TableSplit)o).startRow) &&
283 Bytes.equals(endRow, ((TableSplit)o).endRow) &&
284 regionLocation.equals(((TableSplit)o).regionLocation);
285 }
286
287 @Override
288 public int hashCode() {
289 int result = tableName != null ? tableName.hashCode() : 0;
290 result = 31 * result + (scan != null ? scan.hashCode() : 0);
291 result = 31 * result + (startRow != null ? Arrays.hashCode(startRow) : 0);
292 result = 31 * result + (endRow != null ? Arrays.hashCode(endRow) : 0);
293 result = 31 * result + (regionLocation != null ? regionLocation.hashCode() : 0);
294 return result;
295 }
296 }