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.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.HConstants;
35  import org.apache.hadoop.hbase.classification.InterfaceAudience;
36  import org.apache.hadoop.hbase.classification.InterfaceStability;
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   * Used to perform Get operations on a single row.
45   * <p>
46   * To get everything for a row, instantiate a Get object with the row to get.
47   * To further narrow the scope of what to Get, use the methods below.
48   * <p>
49   * To get all columns from specific families, execute {@link #addFamily(byte[]) addFamily}
50   * for each family to retrieve.
51   * <p>
52   * To get specific columns, execute {@link #addColumn(byte[], byte[]) addColumn}
53   * for each column to retrieve.
54   * <p>
55   * To only retrieve columns within a specific range of version timestamps,
56   * execute {@link #setTimeRange(long, long) setTimeRange}.
57   * <p>
58   * To only retrieve columns with a specific timestamp, execute
59   * {@link #setTimeStamp(long) setTimestamp}.
60   * <p>
61   * To limit the number of versions of each column to be returned, execute
62   * {@link #setMaxVersions(int) setMaxVersions}.
63   * <p>
64   * To add a filter, call {@link #setFilter(Filter) setFilter}.
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     * Create a Get operation for the specified row.
85     * <p>
86     * If no further operations are done, this will get the latest version of
87     * all columns in all families of the specified row.
88     * @param row row key
89     */
90    public Get(byte [] row) {
91      Mutation.checkRow(row);
92      this.row = row;
93    }
94  
95    /**
96     * Copy-constructor
97     *
98     * @param get
99     */
100   public Get(Get get) {
101     this(get.getRow());
102     this.filter = get.getFilter();
103     this.cacheBlocks = get.getCacheBlocks();
104     this.maxVersions = get.getMaxVersions();
105     this.storeLimit = get.getMaxResultsPerColumnFamily();
106     this.storeOffset = get.getRowOffsetPerColumnFamily();
107     this.tr = get.getTimeRange();
108     this.checkExistenceOnly = get.isCheckExistenceOnly();
109     this.closestRowBefore = get.isClosestRowBefore();
110     this.familyMap = get.getFamilyMap();
111     for (Map.Entry<String, byte[]> attr : get.getAttributesMap().entrySet()) {
112       setAttribute(attr.getKey(), attr.getValue());
113     }
114   }
115 
116   public boolean isCheckExistenceOnly() {
117     return checkExistenceOnly;
118   }
119 
120   public Get setCheckExistenceOnly(boolean checkExistenceOnly) {
121     this.checkExistenceOnly = checkExistenceOnly;
122     return this;
123   }
124 
125   public boolean isClosestRowBefore() {
126     return closestRowBefore;
127   }
128 
129   public Get setClosestRowBefore(boolean closestRowBefore) {
130     this.closestRowBefore = closestRowBefore;
131     return this;
132   }
133 
134   /**
135    * Get all columns from the specified family.
136    * <p>
137    * Overrides previous calls to addColumn for this family.
138    * @param family family name
139    * @return the Get object
140    */
141   public Get addFamily(byte [] family) {
142     familyMap.remove(family);
143     familyMap.put(family, null);
144     return this;
145   }
146 
147   /**
148    * Get the column from the specific family with the specified qualifier.
149    * <p>
150    * Overrides previous calls to addFamily for this family.
151    * @param family family name
152    * @param qualifier column qualifier
153    * @return the Get objec
154    */
155   public Get addColumn(byte [] family, byte [] qualifier) {
156     NavigableSet<byte []> set = familyMap.get(family);
157     if(set == null) {
158       set = new TreeSet<byte []>(Bytes.BYTES_COMPARATOR);
159     }
160     if (qualifier == null) {
161       qualifier = HConstants.EMPTY_BYTE_ARRAY;
162     }
163     set.add(qualifier);
164     familyMap.put(family, set);
165     return this;
166   }
167 
168   /**
169    * Get versions of columns only within the specified timestamp range,
170    * [minStamp, maxStamp).
171    * @param minStamp minimum timestamp value, inclusive
172    * @param maxStamp maximum timestamp value, exclusive
173    * @throws IOException if invalid time range
174    * @return this for invocation chaining
175    */
176   public Get setTimeRange(long minStamp, long maxStamp)
177   throws IOException {
178     tr = new TimeRange(minStamp, maxStamp);
179     return this;
180   }
181 
182   /**
183    * Get versions of columns with the specified timestamp.
184    * @param timestamp version timestamp
185    * @return this for invocation chaining
186    */
187   public Get setTimeStamp(long timestamp)
188   throws IOException {
189     try {
190       tr = new TimeRange(timestamp, timestamp+1);
191     } catch(IOException e) {
192       // This should never happen, unless integer overflow or something extremely wrong...
193       LOG.error("TimeRange failed, likely caused by integer overflow. ", e);
194       throw e;
195     }
196     return this;
197   }
198 
199   /**
200    * Get all available versions.
201    * @return this for invocation chaining
202    */
203   public Get setMaxVersions() {
204     this.maxVersions = Integer.MAX_VALUE;
205     return this;
206   }
207 
208   /**
209    * Get up to the specified number of versions of each column.
210    * @param maxVersions maximum versions for each column
211    * @throws IOException if invalid number of versions
212    * @return this for invocation chaining
213    */
214   public Get setMaxVersions(int maxVersions) throws IOException {
215     if(maxVersions <= 0) {
216       throw new IOException("maxVersions must be positive");
217     }
218     this.maxVersions = maxVersions;
219     return this;
220   }
221 
222   /**
223    * Set the maximum number of values to return per row per Column Family
224    * @param limit the maximum number of values returned / row / CF
225    * @return this for invocation chaining
226    */
227   public Get setMaxResultsPerColumnFamily(int limit) {
228     this.storeLimit = limit;
229     return this;
230   }
231 
232   /**
233    * Set offset for the row per Column Family. This offset is only within a particular row/CF
234    * combination. It gets reset back to zero when we move to the next row or CF.
235    * @param offset is the number of kvs that will be skipped.
236    * @return this for invocation chaining
237    */
238   public Get setRowOffsetPerColumnFamily(int offset) {
239     this.storeOffset = offset;
240     return this;
241   }
242 
243   @Override
244   public Get setFilter(Filter filter) {
245     super.setFilter(filter);
246     return this;
247   }
248 
249   /* Accessors */
250 
251   /**
252    * Set whether blocks should be cached for this Get.
253    * <p>
254    * This is true by default.  When true, default settings of the table and
255    * family are used (this will never override caching blocks if the block
256    * cache is disabled for that family or entirely).
257    *
258    * @param cacheBlocks if false, default settings are overridden and blocks
259    * will not be cached
260    */
261   public Get setCacheBlocks(boolean cacheBlocks) {
262     this.cacheBlocks = cacheBlocks;
263     return this;
264   }
265 
266   /**
267    * Get whether blocks should be cached for this Get.
268    * @return true if default caching should be used, false if blocks should not
269    * be cached
270    */
271   public boolean getCacheBlocks() {
272     return cacheBlocks;
273   }
274 
275   /**
276    * Method for retrieving the get's row
277    * @return row
278    */
279   @Override
280   public byte [] getRow() {
281     return this.row;
282   }
283 
284   /**
285    * Method for retrieving the get's maximum number of version
286    * @return the maximum number of version to fetch for this get
287    */
288   public int getMaxVersions() {
289     return this.maxVersions;
290   }
291 
292   /**
293    * Method for retrieving the get's maximum number of values
294    * to return per Column Family
295    * @return the maximum number of values to fetch per CF
296    */
297   public int getMaxResultsPerColumnFamily() {
298     return this.storeLimit;
299   }
300 
301   /**
302    * Method for retrieving the get's offset per row per column
303    * family (#kvs to be skipped)
304    * @return the row offset
305    */
306   public int getRowOffsetPerColumnFamily() {
307     return this.storeOffset;
308   }
309 
310   /**
311    * Method for retrieving the get's TimeRange
312    * @return timeRange
313    */
314   public TimeRange getTimeRange() {
315     return this.tr;
316   }
317 
318   /**
319    * Method for retrieving the keys in the familyMap
320    * @return keys in the current familyMap
321    */
322   public Set<byte[]> familySet() {
323     return this.familyMap.keySet();
324   }
325 
326   /**
327    * Method for retrieving the number of families to get from
328    * @return number of families
329    */
330   public int numFamilies() {
331     return this.familyMap.size();
332   }
333 
334   /**
335    * Method for checking if any families have been inserted into this Get
336    * @return true if familyMap is non empty false otherwise
337    */
338   public boolean hasFamilies() {
339     return !this.familyMap.isEmpty();
340   }
341 
342   /**
343    * Method for retrieving the get's familyMap
344    * @return familyMap
345    */
346   public Map<byte[],NavigableSet<byte[]>> getFamilyMap() {
347     return this.familyMap;
348   }
349 
350   /**
351    * Compile the table and column family (i.e. schema) information
352    * into a String. Useful for parsing and aggregation by debugging,
353    * logging, and administration tools.
354    * @return Map
355    */
356   @Override
357   public Map<String, Object> getFingerprint() {
358     Map<String, Object> map = new HashMap<String, Object>();
359     List<String> families = new ArrayList<String>();
360     map.put("families", families);
361     for (Map.Entry<byte [], NavigableSet<byte[]>> entry :
362       this.familyMap.entrySet()) {
363       families.add(Bytes.toStringBinary(entry.getKey()));
364     }
365     return map;
366   }
367 
368   /**
369    * Compile the details beyond the scope of getFingerprint (row, columns,
370    * timestamps, etc.) into a Map along with the fingerprinted information.
371    * Useful for debugging, logging, and administration tools.
372    * @param maxCols a limit on the number of columns output prior to truncation
373    * @return Map
374    */
375   @Override
376   public Map<String, Object> toMap(int maxCols) {
377     // we start with the fingerprint map and build on top of it.
378     Map<String, Object> map = getFingerprint();
379     // replace the fingerprint's simple list of families with a
380     // map from column families to lists of qualifiers and kv details
381     Map<String, List<String>> columns = new HashMap<String, List<String>>();
382     map.put("families", columns);
383     // add scalar information first
384     map.put("row", Bytes.toStringBinary(this.row));
385     map.put("maxVersions", this.maxVersions);
386     map.put("cacheBlocks", this.cacheBlocks);
387     List<Long> timeRange = new ArrayList<Long>();
388     timeRange.add(this.tr.getMin());
389     timeRange.add(this.tr.getMax());
390     map.put("timeRange", timeRange);
391     int colCount = 0;
392     // iterate through affected families and add details
393     for (Map.Entry<byte [], NavigableSet<byte[]>> entry :
394       this.familyMap.entrySet()) {
395       List<String> familyList = new ArrayList<String>();
396       columns.put(Bytes.toStringBinary(entry.getKey()), familyList);
397       if(entry.getValue() == null) {
398         colCount++;
399         --maxCols;
400         familyList.add("ALL");
401       } else {
402         colCount += entry.getValue().size();
403         if (maxCols <= 0) {
404           continue;
405         }
406         for (byte [] column : entry.getValue()) {
407           if (--maxCols <= 0) {
408             continue;
409           }
410           familyList.add(Bytes.toStringBinary(column));
411         }
412       }
413     }
414     map.put("totalColumns", colCount);
415     if (this.filter != null) {
416       map.put("filter", this.filter.toString());
417     }
418     // add the id if set
419     if (getId() != null) {
420       map.put("id", getId());
421     }
422     return map;
423   }
424 
425   //Row
426   @Override
427   public int compareTo(Row other) {
428     // TODO: This is wrong.  Can't have two gets the same just because on same row.
429     return Bytes.compareTo(this.getRow(), other.getRow());
430   }
431 
432   @Override
433   public int hashCode() {
434     // TODO: This is wrong.  Can't have two gets the same just because on same row.  But it
435     // matches how equals works currently and gets rid of the findbugs warning.
436     return Bytes.hashCode(this.getRow());
437   }
438 
439   @Override
440   public boolean equals(Object obj) {
441     if (this == obj) {
442       return true;
443     }
444     if (obj == null || getClass() != obj.getClass()) {
445       return false;
446     }
447     Row other = (Row) obj;
448     // TODO: This is wrong.  Can't have two gets the same just because on same row.
449     return compareTo(other) == 0;
450   }
451 
452   @Override
453   public Get setAttribute(String name, byte[] value) {
454     return (Get) super.setAttribute(name, value);
455   }
456 
457   @Override
458   public Get setId(String id) {
459     return (Get) super.setId(id);
460   }
461 
462   @Override
463   public Get setAuthorizations(Authorizations authorizations) {
464     return (Get) super.setAuthorizations(authorizations);
465   }
466 
467   @Override
468   public Get setACL(Map<String, Permission> perms) {
469     return (Get) super.setACL(perms);
470   }
471 
472   @Override
473   public Get setACL(String user, Permission perms) {
474     return (Get) super.setACL(user, perms);
475   }
476 
477   @Override
478   public Get setConsistency(Consistency consistency) {
479     return (Get) super.setConsistency(consistency);
480   }
481 
482   @Override
483   public Get setReplicaId(int Id) {
484     return (Get) super.setReplicaId(Id);
485   }
486 
487   @Override
488   public Get setIsolationLevel(IsolationLevel level) {
489       return (Get) super.setIsolationLevel(level);
490   }
491 
492 }