1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.hadoop.hbase.client;
20
21
22 import java.io.IOException;
23 import java.util.ArrayList;
24 import java.util.HashMap;
25 import java.util.List;
26 import java.util.Map;
27 import java.util.NavigableSet;
28 import java.util.Set;
29 import java.util.TreeMap;
30 import java.util.TreeSet;
31
32 import org.apache.commons.logging.Log;
33 import org.apache.commons.logging.LogFactory;
34 import org.apache.hadoop.hbase.classification.InterfaceAudience;
35 import org.apache.hadoop.hbase.classification.InterfaceStability;
36 import org.apache.hadoop.hbase.HConstants;
37 import org.apache.hadoop.hbase.filter.Filter;
38 import org.apache.hadoop.hbase.io.TimeRange;
39 import org.apache.hadoop.hbase.security.access.Permission;
40 import org.apache.hadoop.hbase.security.visibility.Authorizations;
41 import org.apache.hadoop.hbase.util.Bytes;
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66 @InterfaceAudience.Public
67 @InterfaceStability.Stable
68 public class Get extends Query
69 implements Row, Comparable<Row> {
70 private static final Log LOG = LogFactory.getLog(Get.class);
71
72 private byte [] row = null;
73 private int maxVersions = 1;
74 private boolean cacheBlocks = true;
75 private int storeLimit = -1;
76 private int storeOffset = 0;
77 private TimeRange tr = new TimeRange();
78 private boolean checkExistenceOnly = false;
79 private boolean closestRowBefore = false;
80 private Map<byte [], NavigableSet<byte []>> familyMap =
81 new TreeMap<byte [], NavigableSet<byte []>>(Bytes.BYTES_COMPARATOR);
82
83
84
85
86
87
88
89
90 public Get(byte [] row) {
91 Mutation.checkRow(row);
92 this.row = row;
93 }
94
95
96
97
98
99
100 public Get(Get get) {
101 this.filter = get.getFilter();
102 this.cacheBlocks = get.getCacheBlocks();
103 this.maxVersions = get.getMaxVersions();
104 this.storeLimit = get.getMaxResultsPerColumnFamily();
105 this.storeOffset = get.getRowOffsetPerColumnFamily();
106 this.tr = get.getTimeRange();
107 this.checkExistenceOnly = get.isCheckExistenceOnly();
108 this.closestRowBefore = get.isClosestRowBefore();
109 this.familyMap = get.getFamilyMap();
110 for (Map.Entry<String, byte[]> attr : get.getAttributesMap().entrySet()) {
111 setAttribute(attr.getKey(), attr.getValue());
112 }
113 }
114
115 public boolean isCheckExistenceOnly() {
116 return checkExistenceOnly;
117 }
118
119 public Get setCheckExistenceOnly(boolean checkExistenceOnly) {
120 this.checkExistenceOnly = checkExistenceOnly;
121 return this;
122 }
123
124 public boolean isClosestRowBefore() {
125 return closestRowBefore;
126 }
127
128 public Get setClosestRowBefore(boolean closestRowBefore) {
129 this.closestRowBefore = closestRowBefore;
130 return this;
131 }
132
133
134
135
136
137
138
139
140 public Get addFamily(byte [] family) {
141 familyMap.remove(family);
142 familyMap.put(family, null);
143 return this;
144 }
145
146
147
148
149
150
151
152
153
154 public Get addColumn(byte [] family, byte [] qualifier) {
155 NavigableSet<byte []> set = familyMap.get(family);
156 if(set == null) {
157 set = new TreeSet<byte []>(Bytes.BYTES_COMPARATOR);
158 }
159 if (qualifier == null) {
160 qualifier = HConstants.EMPTY_BYTE_ARRAY;
161 }
162 set.add(qualifier);
163 familyMap.put(family, set);
164 return this;
165 }
166
167
168
169
170
171
172
173
174
175 public Get setTimeRange(long minStamp, long maxStamp)
176 throws IOException {
177 tr = new TimeRange(minStamp, maxStamp);
178 return this;
179 }
180
181
182
183
184
185
186 public Get setTimeStamp(long timestamp)
187 throws IOException {
188 try {
189 tr = new TimeRange(timestamp, timestamp+1);
190 } catch(IOException e) {
191
192 LOG.error("TimeRange failed, likely caused by integer overflow. ", e);
193 throw e;
194 }
195 return this;
196 }
197
198
199
200
201
202 public Get setMaxVersions() {
203 this.maxVersions = Integer.MAX_VALUE;
204 return this;
205 }
206
207
208
209
210
211
212
213 public Get setMaxVersions(int maxVersions) throws IOException {
214 if(maxVersions <= 0) {
215 throw new IOException("maxVersions must be positive");
216 }
217 this.maxVersions = maxVersions;
218 return this;
219 }
220
221
222
223
224
225
226 public Get setMaxResultsPerColumnFamily(int limit) {
227 this.storeLimit = limit;
228 return this;
229 }
230
231
232
233
234
235
236
237 public Get setRowOffsetPerColumnFamily(int offset) {
238 this.storeOffset = offset;
239 return this;
240 }
241
242 @Override
243 public Get setFilter(Filter filter) {
244 super.setFilter(filter);
245 return this;
246 }
247
248
249
250
251
252
253
254
255
256
257
258
259
260 public Get setCacheBlocks(boolean cacheBlocks) {
261 this.cacheBlocks = cacheBlocks;
262 return this;
263 }
264
265
266
267
268
269
270 public boolean getCacheBlocks() {
271 return cacheBlocks;
272 }
273
274
275
276
277
278 @Override
279 public byte [] getRow() {
280 return this.row;
281 }
282
283
284
285
286
287 public int getMaxVersions() {
288 return this.maxVersions;
289 }
290
291
292
293
294
295
296 public int getMaxResultsPerColumnFamily() {
297 return this.storeLimit;
298 }
299
300
301
302
303
304
305 public int getRowOffsetPerColumnFamily() {
306 return this.storeOffset;
307 }
308
309
310
311
312
313 public TimeRange getTimeRange() {
314 return this.tr;
315 }
316
317
318
319
320
321 public Set<byte[]> familySet() {
322 return this.familyMap.keySet();
323 }
324
325
326
327
328
329 public int numFamilies() {
330 return this.familyMap.size();
331 }
332
333
334
335
336
337 public boolean hasFamilies() {
338 return !this.familyMap.isEmpty();
339 }
340
341
342
343
344
345 public Map<byte[],NavigableSet<byte[]>> getFamilyMap() {
346 return this.familyMap;
347 }
348
349
350
351
352
353
354
355 @Override
356 public Map<String, Object> getFingerprint() {
357 Map<String, Object> map = new HashMap<String, Object>();
358 List<String> families = new ArrayList<String>();
359 map.put("families", families);
360 for (Map.Entry<byte [], NavigableSet<byte[]>> entry :
361 this.familyMap.entrySet()) {
362 families.add(Bytes.toStringBinary(entry.getKey()));
363 }
364 return map;
365 }
366
367
368
369
370
371
372
373
374 @Override
375 public Map<String, Object> toMap(int maxCols) {
376
377 Map<String, Object> map = getFingerprint();
378
379
380 Map<String, List<String>> columns = new HashMap<String, List<String>>();
381 map.put("families", columns);
382
383 map.put("row", Bytes.toStringBinary(this.row));
384 map.put("maxVersions", this.maxVersions);
385 map.put("cacheBlocks", this.cacheBlocks);
386 List<Long> timeRange = new ArrayList<Long>();
387 timeRange.add(this.tr.getMin());
388 timeRange.add(this.tr.getMax());
389 map.put("timeRange", timeRange);
390 int colCount = 0;
391
392 for (Map.Entry<byte [], NavigableSet<byte[]>> entry :
393 this.familyMap.entrySet()) {
394 List<String> familyList = new ArrayList<String>();
395 columns.put(Bytes.toStringBinary(entry.getKey()), familyList);
396 if(entry.getValue() == null) {
397 colCount++;
398 --maxCols;
399 familyList.add("ALL");
400 } else {
401 colCount += entry.getValue().size();
402 if (maxCols <= 0) {
403 continue;
404 }
405 for (byte [] column : entry.getValue()) {
406 if (--maxCols <= 0) {
407 continue;
408 }
409 familyList.add(Bytes.toStringBinary(column));
410 }
411 }
412 }
413 map.put("totalColumns", colCount);
414 if (this.filter != null) {
415 map.put("filter", this.filter.toString());
416 }
417
418 if (getId() != null) {
419 map.put("id", getId());
420 }
421 return map;
422 }
423
424
425 @Override
426 public int compareTo(Row other) {
427
428 return Bytes.compareTo(this.getRow(), other.getRow());
429 }
430
431 @Override
432 public int hashCode() {
433
434
435 return Bytes.hashCode(this.getRow());
436 }
437
438 @Override
439 public boolean equals(Object obj) {
440 if (this == obj) {
441 return true;
442 }
443 if (obj == null || getClass() != obj.getClass()) {
444 return false;
445 }
446 Row other = (Row) obj;
447
448 return compareTo(other) == 0;
449 }
450
451 @Override
452 public Get setAttribute(String name, byte[] value) {
453 return (Get) super.setAttribute(name, value);
454 }
455
456 @Override
457 public Get setId(String id) {
458 return (Get) super.setId(id);
459 }
460
461 @Override
462 public Get setAuthorizations(Authorizations authorizations) {
463 return (Get) super.setAuthorizations(authorizations);
464 }
465
466 @Override
467 public Get setACL(Map<String, Permission> perms) {
468 return (Get) super.setACL(perms);
469 }
470
471 @Override
472 public Get setACL(String user, Permission perms) {
473 return (Get) super.setACL(user, perms);
474 }
475
476 @Override
477 public Get setConsistency(Consistency consistency) {
478 return (Get) super.setConsistency(consistency);
479 }
480
481 @Override
482 public Get setReplicaId(int Id) {
483 return (Get) super.setReplicaId(Id);
484 }
485
486 @Override
487 public Get setIsolationLevel(IsolationLevel level) {
488 return (Get) super.setIsolationLevel(level);
489 }
490
491 }