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(get.getRow());
102
103 this.setFilter(get.getFilter());
104 this.setReplicaId(get.getReplicaId());
105 this.setConsistency(get.getConsistency());
106
107 this.cacheBlocks = get.getCacheBlocks();
108 this.maxVersions = get.getMaxVersions();
109 this.storeLimit = get.getMaxResultsPerColumnFamily();
110 this.storeOffset = get.getRowOffsetPerColumnFamily();
111 this.tr = get.getTimeRange();
112 this.checkExistenceOnly = get.isCheckExistenceOnly();
113 this.closestRowBefore = get.isClosestRowBefore();
114 Map<byte[], NavigableSet<byte[]>> fams = get.getFamilyMap();
115 for (Map.Entry<byte[],NavigableSet<byte[]>> entry : fams.entrySet()) {
116 byte [] fam = entry.getKey();
117 NavigableSet<byte[]> cols = entry.getValue();
118 if (cols != null && cols.size() > 0) {
119 for (byte[] col : cols) {
120 addColumn(fam, col);
121 }
122 } else {
123 addFamily(fam);
124 }
125 }
126 for (Map.Entry<String, byte[]> attr : get.getAttributesMap().entrySet()) {
127 setAttribute(attr.getKey(), attr.getValue());
128 }
129 }
130
131 public boolean isCheckExistenceOnly() {
132 return checkExistenceOnly;
133 }
134
135 public Get setCheckExistenceOnly(boolean checkExistenceOnly) {
136 this.checkExistenceOnly = checkExistenceOnly;
137 return this;
138 }
139
140 public boolean isClosestRowBefore() {
141 return closestRowBefore;
142 }
143
144 public Get setClosestRowBefore(boolean closestRowBefore) {
145 this.closestRowBefore = closestRowBefore;
146 return this;
147 }
148
149
150
151
152
153
154
155
156 public Get addFamily(byte [] family) {
157 familyMap.remove(family);
158 familyMap.put(family, null);
159 return this;
160 }
161
162
163
164
165
166
167
168
169
170 public Get addColumn(byte [] family, byte [] qualifier) {
171 NavigableSet<byte []> set = familyMap.get(family);
172 if(set == null) {
173 set = new TreeSet<byte []>(Bytes.BYTES_COMPARATOR);
174 }
175 if (qualifier == null) {
176 qualifier = HConstants.EMPTY_BYTE_ARRAY;
177 }
178 set.add(qualifier);
179 familyMap.put(family, set);
180 return this;
181 }
182
183
184
185
186
187
188
189
190
191 public Get setTimeRange(long minStamp, long maxStamp)
192 throws IOException {
193 tr = new TimeRange(minStamp, maxStamp);
194 return this;
195 }
196
197
198
199
200
201
202 public Get setTimeStamp(long timestamp)
203 throws IOException {
204 try {
205 tr = new TimeRange(timestamp, timestamp+1);
206 } catch(IOException e) {
207
208 LOG.error("TimeRange failed, likely caused by integer overflow. ", e);
209 throw e;
210 }
211 return this;
212 }
213
214
215
216
217
218 public Get setMaxVersions() {
219 this.maxVersions = Integer.MAX_VALUE;
220 return this;
221 }
222
223
224
225
226
227
228
229 public Get setMaxVersions(int maxVersions) throws IOException {
230 if(maxVersions <= 0) {
231 throw new IOException("maxVersions must be positive");
232 }
233 this.maxVersions = maxVersions;
234 return this;
235 }
236
237
238
239
240
241
242 public Get setMaxResultsPerColumnFamily(int limit) {
243 this.storeLimit = limit;
244 return this;
245 }
246
247
248
249
250
251
252
253 public Get setRowOffsetPerColumnFamily(int offset) {
254 this.storeOffset = offset;
255 return this;
256 }
257
258 @Override
259 public Get setFilter(Filter filter) {
260 super.setFilter(filter);
261 return this;
262 }
263
264
265
266
267
268
269
270
271
272
273
274
275
276 public Get setCacheBlocks(boolean cacheBlocks) {
277 this.cacheBlocks = cacheBlocks;
278 return this;
279 }
280
281
282
283
284
285
286 public boolean getCacheBlocks() {
287 return cacheBlocks;
288 }
289
290
291
292
293
294 @Override
295 public byte [] getRow() {
296 return this.row;
297 }
298
299
300
301
302
303 public int getMaxVersions() {
304 return this.maxVersions;
305 }
306
307
308
309
310
311
312 public int getMaxResultsPerColumnFamily() {
313 return this.storeLimit;
314 }
315
316
317
318
319
320
321 public int getRowOffsetPerColumnFamily() {
322 return this.storeOffset;
323 }
324
325
326
327
328
329 public TimeRange getTimeRange() {
330 return this.tr;
331 }
332
333
334
335
336
337 public Set<byte[]> familySet() {
338 return this.familyMap.keySet();
339 }
340
341
342
343
344
345 public int numFamilies() {
346 return this.familyMap.size();
347 }
348
349
350
351
352
353 public boolean hasFamilies() {
354 return !this.familyMap.isEmpty();
355 }
356
357
358
359
360
361 public Map<byte[],NavigableSet<byte[]>> getFamilyMap() {
362 return this.familyMap;
363 }
364
365
366
367
368
369
370
371 @Override
372 public Map<String, Object> getFingerprint() {
373 Map<String, Object> map = new HashMap<String, Object>();
374 List<String> families = new ArrayList<String>();
375 map.put("families", families);
376 for (Map.Entry<byte [], NavigableSet<byte[]>> entry :
377 this.familyMap.entrySet()) {
378 families.add(Bytes.toStringBinary(entry.getKey()));
379 }
380 return map;
381 }
382
383
384
385
386
387
388
389
390 @Override
391 public Map<String, Object> toMap(int maxCols) {
392
393 Map<String, Object> map = getFingerprint();
394
395
396 Map<String, List<String>> columns = new HashMap<String, List<String>>();
397 map.put("families", columns);
398
399 map.put("row", Bytes.toStringBinary(this.row));
400 map.put("maxVersions", this.maxVersions);
401 map.put("cacheBlocks", this.cacheBlocks);
402 List<Long> timeRange = new ArrayList<Long>();
403 timeRange.add(this.tr.getMin());
404 timeRange.add(this.tr.getMax());
405 map.put("timeRange", timeRange);
406 int colCount = 0;
407
408 for (Map.Entry<byte [], NavigableSet<byte[]>> entry :
409 this.familyMap.entrySet()) {
410 List<String> familyList = new ArrayList<String>();
411 columns.put(Bytes.toStringBinary(entry.getKey()), familyList);
412 if(entry.getValue() == null) {
413 colCount++;
414 --maxCols;
415 familyList.add("ALL");
416 } else {
417 colCount += entry.getValue().size();
418 if (maxCols <= 0) {
419 continue;
420 }
421 for (byte [] column : entry.getValue()) {
422 if (--maxCols <= 0) {
423 continue;
424 }
425 familyList.add(Bytes.toStringBinary(column));
426 }
427 }
428 }
429 map.put("totalColumns", colCount);
430 if (this.filter != null) {
431 map.put("filter", this.filter.toString());
432 }
433
434 if (getId() != null) {
435 map.put("id", getId());
436 }
437 return map;
438 }
439
440
441 @Override
442 public int compareTo(Row other) {
443
444 return Bytes.compareTo(this.getRow(), other.getRow());
445 }
446
447 @Override
448 public int hashCode() {
449
450
451 return Bytes.hashCode(this.getRow());
452 }
453
454 @Override
455 public boolean equals(Object obj) {
456 if (this == obj) {
457 return true;
458 }
459 if (obj == null || getClass() != obj.getClass()) {
460 return false;
461 }
462 Row other = (Row) obj;
463
464 return compareTo(other) == 0;
465 }
466
467 @Override
468 public Get setAttribute(String name, byte[] value) {
469 return (Get) super.setAttribute(name, value);
470 }
471
472 @Override
473 public Get setId(String id) {
474 return (Get) super.setId(id);
475 }
476
477 @Override
478 public Get setAuthorizations(Authorizations authorizations) {
479 return (Get) super.setAuthorizations(authorizations);
480 }
481
482 @Override
483 public Get setACL(Map<String, Permission> perms) {
484 return (Get) super.setACL(perms);
485 }
486
487 @Override
488 public Get setACL(String user, Permission perms) {
489 return (Get) super.setACL(user, perms);
490 }
491
492 @Override
493 public Get setConsistency(Consistency consistency) {
494 return (Get) super.setConsistency(consistency);
495 }
496
497 @Override
498 public Get setReplicaId(int Id) {
499 return (Get) super.setReplicaId(Id);
500 }
501
502 @Override
503 public Get setIsolationLevel(IsolationLevel level) {
504 return (Get) super.setIsolationLevel(level);
505 }
506
507 }