accumulo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ktur...@apache.org
Subject svn commit: r1434768 - in /accumulo/trunk/core/src: main/java/org/apache/accumulo/core/iterators/user/KeyTransformingIterator.java test/java/org/apache/accumulo/core/iterators/user/KeyTransformingIteratorTest.java
Date Thu, 17 Jan 2013 16:33:47 GMT
Author: kturner
Date: Thu Jan 17 16:33:47 2013
New Revision: 1434768

URL: http://svn.apache.org/viewvc?rev=1434768&view=rev
Log:
ACCUMULO-956 formatted source code

Modified:
    accumulo/trunk/core/src/main/java/org/apache/accumulo/core/iterators/user/KeyTransformingIterator.java
    accumulo/trunk/core/src/test/java/org/apache/accumulo/core/iterators/user/KeyTransformingIteratorTest.java

Modified: accumulo/trunk/core/src/main/java/org/apache/accumulo/core/iterators/user/KeyTransformingIterator.java
URL: http://svn.apache.org/viewvc/accumulo/trunk/core/src/main/java/org/apache/accumulo/core/iterators/user/KeyTransformingIterator.java?rev=1434768&r1=1434767&r2=1434768&view=diff
==============================================================================
--- accumulo/trunk/core/src/main/java/org/apache/accumulo/core/iterators/user/KeyTransformingIterator.java
(original)
+++ accumulo/trunk/core/src/main/java/org/apache/accumulo/core/iterators/user/KeyTransformingIterator.java
Thu Jan 17 16:33:47 2013
@@ -45,49 +45,30 @@ import org.apache.hadoop.io.Text;
 import org.apache.log4j.Logger;
 
 /**
- * The KeyTransformingIterator allows portions of a key (except for the row)
- * to be transformed.  This iterator handles the details that come with modifying
- * keys (i.e., that the sort order could change).  In order to do so, however,
- * the iterator must put all keys sharing the same prefix in memory.  Prefix
- * is defined as the parts of the key that are not modified by this iterator.
- * That is, if the iterator modifies column qualifier and timestamp, then the
- * prefix is row and column family.  In that case, the iterator must load all
- * column qualifiers for each row/column family pair into memory.  Given this
- * constraint, care must be taken by users of this iterator to ensure it is
- * not run in such a way that will overrun memory in a tablet server.
+ * The KeyTransformingIterator allows portions of a key (except for the row) to be transformed.
This iterator handles the details that come with modifying keys
+ * (i.e., that the sort order could change). In order to do so, however, the iterator must
put all keys sharing the same prefix in memory. Prefix is defined as
+ * the parts of the key that are not modified by this iterator. That is, if the iterator
modifies column qualifier and timestamp, then the prefix is row and
+ * column family. In that case, the iterator must load all column qualifiers for each row/column
family pair into memory. Given this constraint, care must be
+ * taken by users of this iterator to ensure it is not run in such a way that will overrun
memory in a tablet server.
  * <p>
- * If the implementing iterator is transforming column families, then it
- * must also override {@link #untransformColumnFamilies(Collection)} to handle
- * the case when column families are fetched at scan time.  The fetched column
- * families will/must be in the transformed space, and the untransformed column
- * families need to be passed to this iterator's source.  If it is not possible
- * to write a reverse transformation (e.g., the column family transformation
- * depends on the row value or something like that), then the iterator must
- * not fetch specific column families (or only fetch column families that are
- * known to not transform at all).
+ * If the implementing iterator is transforming column families, then it must also override
{@link #untransformColumnFamilies(Collection)} to handle the case
+ * when column families are fetched at scan time. The fetched column families will/must be
in the transformed space, and the untransformed column families need
+ * to be passed to this iterator's source. If it is not possible to write a reverse transformation
(e.g., the column family transformation depends on the row
+ * value or something like that), then the iterator must not fetch specific column families
(or only fetch column families that are known to not transform at
+ * all).
  * <p>
- * If the implementing iterator is transforming column visibilities, then
- * users must be careful NOT to fetch column qualifiers from the scanner.
- * The reason for this is due to ACCUMULO-??? (insert issue number).
+ * If the implementing iterator is transforming column visibilities, then users must be careful
NOT to fetch column qualifiers from the scanner. The reason for
+ * this is due to ACCUMULO-??? (insert issue number).
  * <p>
- * If the implementing iterator is transforming column visibilities, then the
- * user should be sure to supply authorizations via the {@link #AUTH_OPT}
- * iterator option (note that this is only necessary for scan scope iterators).
- * The supplied authorizations should be in the transformed space, but the
- * authorizations supplied to the scanner should be in the untransformed
- * space.  That is, if the iterator transforms A to 1, B to 2, C to 3, etc,
- * then the auths supplied when the scanner is constructed should be A,B,C,...
- * and the auths supplied to the iterator should be 1,2,3,...  The reason
- * for this is that the scanner performs security filtering before this
- * iterator is called, so the authorizations need to be in the original
- * untransformed space.  Since the iterator can transform visibilities, it is
- * possible that it could produce visibilities that the user cannot see,
- * so the transformed keys must be tested to ensure the user is allowed to view 
- * them.  Note that this test is not necessary when the iterator is not used
- * in the scan scope since no security filtering is performed during major and
- * minor compactions.  It should also be noted that this iterator implements the
- * security filtering rather than relying on a follow-on iterator to do it so
- * that we ensure the test is performed.
+ * If the implementing iterator is transforming column visibilities, then the user should
be sure to supply authorizations via the {@link #AUTH_OPT} iterator
+ * option (note that this is only necessary for scan scope iterators). The supplied authorizations
should be in the transformed space, but the authorizations
+ * supplied to the scanner should be in the untransformed space. That is, if the iterator
transforms A to 1, B to 2, C to 3, etc, then the auths supplied when
+ * the scanner is constructed should be A,B,C,... and the auths supplied to the iterator
should be 1,2,3,... The reason for this is that the scanner performs
+ * security filtering before this iterator is called, so the authorizations need to be in
the original untransformed space. Since the iterator can transform
+ * visibilities, it is possible that it could produce visibilities that the user cannot see,
so the transformed keys must be tested to ensure the user is
+ * allowed to view them. Note that this test is not necessary when the iterator is not used
in the scan scope since no security filtering is performed during
+ * major and minor compactions. It should also be noted that this iterator implements the
security filtering rather than relying on a follow-on iterator to do
+ * it so that we ensure the test is performed.
  */
 abstract public class KeyTransformingIterator extends WrappingIterator implements OptionDescriber
{
   public static final String AUTH_OPT = "authorizations";
@@ -104,15 +85,14 @@ abstract public class KeyTransformingIte
   private LRUMap visibleCache = null;
   private LRUMap parsedVisibilitiesCache = null;
   
-  private static Comparator<Pair<Key,Value>> keyComparator = new Comparator<Pair<Key,Value>>()
{    
+  private static Comparator<Pair<Key,Value>> keyComparator = new Comparator<Pair<Key,Value>>()
{
     @Override
     public int compare(Pair<Key,Value> o1, Pair<Key,Value> o2) {
       return o1.getFirst().compareTo(o2.getFirst());
     }
   };
   
-  public KeyTransformingIterator() {
-  }
+  public KeyTransformingIterator() {}
   
   @Override
   public void init(SortedKeyValueIterator<Key,Value> source, Map<String,String>
options, IteratorEnvironment env) throws IOException {
@@ -132,8 +112,8 @@ abstract public class KeyTransformingIte
   @Override
   public IteratorOptions describeOptions() {
     String desc = "This iterator allows keys to be transformed.";
-    String authDesc = "Comma-separated list of user's scan authorizations.  " +
-    		"If excluded or empty, then no visibility check is performed on transformed keys.";
+    String authDesc = "Comma-separated list of user's scan authorizations.  "
+        + "If excluded or empty, then no visibility check is performed on transformed keys.";
     return new IteratorOptions(getClass().getSimpleName(), desc, Collections.singletonMap(AUTH_OPT,
authDesc), null);
   }
   
@@ -195,14 +175,14 @@ abstract public class KeyTransformingIte
     // Move on to the next entry since we returned the entry at keyPos before
     if (keyPos >= 0)
       keyPos++;
-
-    // If we emptied out the transformed key map then transform the next key 
-    // set from the source.  It’s possible that transformation could produce keys
+    
+    // If we emptied out the transformed key map then transform the next key
+    // set from the source. It’s possible that transformation could produce keys
     // that are outside of our range or are not visible to the end user, so after the
-    // call below we might not have added any keys to the map.  Keep going until
+    // call below we might not have added any keys to the map. Keep going until
     // we either get some keys in the map or exhaust the source iterator.
     while (!hasTop() && super.hasTop())
-      transformKeys();  
+      transformKeys();
   }
   
   @Override
@@ -212,7 +192,7 @@ abstract public class KeyTransformingIte
     seekColumnFamiliesInclusive = inclusive;
 
     // Seek the source iterator, but use a recalculated range that ensures
-    // we see all keys with the same "prefix."  We need to do this since
+    // we see all keys with the same "prefix." We need to do this since
     // transforming could change the sort order and transformed keys that
     // are before the range start could be inside the range after transformation.
     super.seek(computeReseekRange(range), untransformColumnFamilies(columnFamilies), inclusive);
@@ -220,9 +200,9 @@ abstract public class KeyTransformingIte
     // Range clipping could cause us to trim out all the keys we transformed.
     // Keep looping until we either have some keys in the output range, or have
     // exhausted the source iterator.
-    keyPos = -1;  // “Clear” list so hasTop returns false to get us into the loop
(transformKeys actually clears)
+    keyPos = -1; // “Clear” list so hasTop returns false to get us into the loop
(transformKeys actually clears)
     while (!hasTop() && super.hasTop()) {
-      // Build up a sorted list of all keys for the same prefix.  When
+      // Build up a sorted list of all keys for the same prefix. When
       // people ask for keys, return from this list first until it is empty
       // before incrementing the source iterator.
       transformKeys();
@@ -230,10 +210,8 @@ abstract public class KeyTransformingIte
   }
   
   /**
-   * Reads all keys matching the first key's prefix from the source
-   * iterator, transforms them, and sorts the resulting keys.  Transformed
-   * keys that fall outside of our seek range or can't be seen by the
-   * user are excluded.
+   * Reads all keys matching the first key's prefix from the source iterator, transforms
them, and sorts the resulting keys. Transformed keys that fall outside
+   * of our seek range or can't be seen by the user are excluded.
    */
   protected void transformKeys() throws IOException {
     keyPos = -1;
@@ -244,7 +222,7 @@ abstract public class KeyTransformingIte
       Key sourceTopKey = super.getTopKey();
 
       // If the source key equals our prefix key (up to the prefix), then
-      // we have a key that needs transformed.  Otherwise, we're done.
+      // we have a key that needs transformed. Otherwise, we're done.
       if (sourceTopKey.equals(prefixKey, getKeyPrefix())) {
         Key transformedKey = transformKey(sourceTopKey);
         
@@ -256,7 +234,7 @@ abstract public class KeyTransformingIte
         // in the key prefix here...
 
         // Transformation could have produced a key that falls outside
-        // of the seek range, or one that the user cannot see.  Check
+        // of the seek range, or one that the user cannot see. Check
         // these before adding it to the output list.
         if (includeTransformedKey(transformedKey))
           keys.add(new Pair<Key,Value>(transformedKey, new Value(super.getTopValue())));
@@ -274,17 +252,13 @@ abstract public class KeyTransformingIte
   }
   
   /**
-   * Determines whether or not to include {@code transformedKey} in the
-   * output.  It is possible that transformation could have produced a key
-   * that falls outside of the seek range, a key with a visibility the user
-   * can't see, a key with a visibility that doesn't parse, or a key with a
-   * column family that wasn't fetched.  We only do some checks (outside the
-   * range, user can see) if we're scanning.  The range check is not done for
-   * major/minor compaction since seek ranges won't be in our transformed key
-   * space and we will never change the row so we can't produce keys that
-   * would fall outside the tablet anyway.  
+   * Determines whether or not to include {@code transformedKey} in the output. It is possible
that transformation could have produced a key that falls outside
+   * of the seek range, a key with a visibility the user can't see, a key with a visibility
that doesn't parse, or a key with a column family that wasn't
+   * fetched. We only do some checks (outside the range, user can see) if we're scanning.
The range check is not done for major/minor compaction since seek
+   * ranges won't be in our transformed key space and we will never change the row so we
can't produce keys that would fall outside the tablet anyway.
    * 
-   * @param transformedKey the key to check
+   * @param transformedKey
+   *          the key to check
    * @return {@code true} if the key should be included and {@code false} if not
    */
   protected boolean includeTransformedKey(Key transformedKey) {
@@ -296,17 +270,13 @@ abstract public class KeyTransformingIte
   }
   
   /**
-   * Indicates whether or not the user is able to see {@code key}.  If the
-   * user has not supplied authorizations, or the iterator is not in the
-   * scan scope, then this method simply returns {@code true}.  Otherwise,
-   * {@code key}'s column visibility is tested against the user-supplied
-   * authorizations, and the test result is returned.  For performance,
-   * the test results are cached so that the same visibility is not tested
-   * multiple times.
+   * Indicates whether or not the user is able to see {@code key}. If the user has not supplied
authorizations, or the iterator is not in the scan scope, then
+   * this method simply returns {@code true}. Otherwise, {@code key}'s column visibility
is tested against the user-supplied authorizations, and the test result
+   * is returned. For performance, the test results are cached so that the same visibility
is not tested multiple times.
    * 
-   * @param key the key to test 
-   * @return {@code true} if the key is visible or iterator is not scanning,
-   *         and {@code false} if not
+   * @param key
+   *          the key to test
+   * @return {@code true} if the key is visible or iterator is not scanning, and {@code false}
if not
    */
   protected boolean canSee(Key key) {
     // Ensure that the visibility (which could have been transformed) parses.
@@ -344,12 +314,11 @@ abstract public class KeyTransformingIte
   }
   
   /**
-   * Indicates whether or not {@code key} can be seen, according to the
-   * fetched column families for this iterator.
+   * Indicates whether or not {@code key} can be seen, according to the fetched column families
for this iterator.
    * 
-   * @param key the key whose column family is to be tested
-   * @return {@code true} if {@code key}'s column family is one of those fetched
-   *         in the set passed to our {@link #seek(Range, Collection, boolean)} method
+   * @param key
+   *          the key whose column family is to be tested
+   * @return {@code true} if {@code key}'s column family is one of those fetched in the set
passed to our {@link #seek(Range, Collection, boolean)} method
    */
   protected boolean canSeeColumnFamily(Key key) {
     boolean visible = true;
@@ -364,12 +333,11 @@ abstract public class KeyTransformingIte
   }
 
   /**
-   * Possibly expand {@code range} to include everything for the key prefix
-   * we are working with.  That is, if our prefix is ROW_COLFAM, then we
-   * need to expand the range so we're sure to include all entries having
-   * the same row and column family as the start/end of the range.
+   * Possibly expand {@code range} to include everything for the key prefix we are working
with. That is, if our prefix is ROW_COLFAM, then we need to expand
+   * the range so we're sure to include all entries having the same row and column family
as the start/end of the range.
    * 
-   * @param range the range to expand
+   * @param range
+   *          the range to expand
    * @return the modified range
    */
   protected Range computeReseekRange(Range range) {
@@ -391,18 +359,18 @@ abstract public class KeyTransformingIte
   }
   
   /**
-   * Indicates whether or not any part of {@code key} excluding
-   * {@code part} is set.  For example, if part is ROW_COLFAM_COLQUAL,
-   * then this method determines whether or not the column visibility,
-   * timestamp, or delete flag is set on {@code key}.
+   * Indicates whether or not any part of {@code key} excluding {@code part} is set. For
example, if part is ROW_COLFAM_COLQUAL, then this method determines
+   * whether or not the column visibility, timestamp, or delete flag is set on {@code key}.
    * 
-   * @param key the key to check
-   * @param part the part of the key that doesn't need to be checked (everything after does)
+   * @param key
+   *          the key to check
+   * @param part
+   *          the part of the key that doesn't need to be checked (everything after does)
    * @return {@code true} if anything after {@code part} is set on {@code key}, and {@code
false} if not
    */
   protected boolean isSetAfterPart(Key key, PartialKey part) {
     boolean isSet = false;
-    if (key != null) {        
+    if (key != null) {
       // Breaks excluded on purpose.
       switch (part) {
         case ROW:
@@ -423,13 +391,13 @@ abstract public class KeyTransformingIte
   }
   
   /**
-   * Creates a copy of {@code key}, copying only the parts of the key specified
-   * in {@code part}.  For example, if {@code part} is ROW_COLFAM_COLQUAL, then
-   * this method would copy the row, column family, and column qualifier from
-   * {@code key} into a new key.
+   * Creates a copy of {@code key}, copying only the parts of the key specified in {@code
part}. For example, if {@code part} is ROW_COLFAM_COLQUAL, then this
+   * method would copy the row, column family, and column qualifier from {@code key} into
a new key.
    * 
-   * @param key the key to copy
-   * @param part the parts of {@code key} to copy
+   * @param key
+   *          the key to copy
+   * @param part
+   *          the parts of {@code key} to copy
    * @return the new key containing {@code part} of {@code key}
    */
   protected Key copyPartialKey(Key key, PartialKey part) {
@@ -448,8 +416,7 @@ abstract public class KeyTransformingIte
         keyCopy = new Key(key.getRow(), key.getColumnFamily(), key.getColumnQualifier(),
key.getColumnVisibility());
         break;
       case ROW_COLFAM_COLQUAL_COLVIS_TIME:
-        keyCopy = new Key(key.getRow(), key.getColumnFamily(), key.getColumnQualifier(),
-          key.getColumnVisibility(), key.getTimestamp());
+        keyCopy = new Key(key.getRow(), key.getColumnFamily(), key.getColumnQualifier(),
key.getColumnVisibility(), key.getTimestamp());
         break;
       default:
         throw new IllegalArgumentException("Unsupported key part: " + part);
@@ -458,8 +425,7 @@ abstract public class KeyTransformingIte
   }
   
   /**
-   * Make a new key with all parts (including delete flag) coming from {@code originalKey}
but
-   * use {@code newColFam} as the column family.
+   * Make a new key with all parts (including delete flag) coming from {@code originalKey}
but use {@code newColFam} as the column family.
    */
   protected Key replaceColumnFamily(Key originalKey, Text newColFam) {
     byte[] row = originalKey.getRowData().toArray();
@@ -467,18 +433,13 @@ abstract public class KeyTransformingIte
     byte[] cq = originalKey.getColumnQualifierData().toArray();
     byte[] cv = originalKey.getColumnVisibilityData().toArray();
     long timestamp = originalKey.getTimestamp();
-    Key newKey = new Key(row, 0, row.length,
-        cf, 0, newColFam.getLength(), 
-        cq, 0, cq.length, 
-        cv, 0, cv.length,
-        timestamp);
+    Key newKey = new Key(row, 0, row.length, cf, 0, newColFam.getLength(), cq, 0, cq.length,
cv, 0, cv.length, timestamp);
     newKey.setDeleted(originalKey.isDeleted());
     return newKey;
   }
   
   /**
-   * Make a new key with all parts (including delete flag) coming from {@code originalKey}
but
-   * use {@code newColQual} as the column qualifier.
+   * Make a new key with all parts (including delete flag) coming from {@code originalKey}
but use {@code newColQual} as the column qualifier.
    */
   protected Key replaceColumnQualifier(Key originalKey, Text newColQual) {
     byte[] row = originalKey.getRowData().toArray();
@@ -486,18 +447,13 @@ abstract public class KeyTransformingIte
     byte[] cq = newColQual.getBytes();
     byte[] cv = originalKey.getColumnVisibilityData().toArray();
     long timestamp = originalKey.getTimestamp();
-    Key newKey = new Key(row, 0, row.length,
-        cf, 0, cf.length, 
-        cq, 0, newColQual.getLength(), 
-        cv, 0, cv.length,
-        timestamp);
+    Key newKey = new Key(row, 0, row.length, cf, 0, cf.length, cq, 0, newColQual.getLength(),
cv, 0, cv.length, timestamp);
     newKey.setDeleted(originalKey.isDeleted());
     return newKey;
   }
   
   /**
-   * Make a new key with all parts (including delete flag) coming from {@code originalKey}
but
-   * use {@code newColVis} as the column visibility.
+   * Make a new key with all parts (including delete flag) coming from {@code originalKey}
but use {@code newColVis} as the column visibility.
    */
   protected Key replaceColumnVisibility(Key originalKey, Text newColVis) {
     byte[] row = originalKey.getRowData().toArray();
@@ -505,18 +461,14 @@ abstract public class KeyTransformingIte
     byte[] cq = originalKey.getColumnQualifierData().toArray();
     byte[] cv = newColVis.getBytes();
     long timestamp = originalKey.getTimestamp();
-    Key newKey = new Key(row, 0, row.length,
-        cf, 0, cf.length, 
-        cq, 0, cq.length, 
-        cv, 0, newColVis.getLength(),
-        timestamp);
+    Key newKey = new Key(row, 0, row.length, cf, 0, cf.length, cq, 0, cq.length, cv, 0, newColVis.getLength(),
timestamp);
     newKey.setDeleted(originalKey.isDeleted());
     return newKey;
   }
   
   /**
-   * Make a new key with a column family, column qualifier, and column visibility.  
-   * Copy the rest of the parts of the key (including delete flag) from {@code originalKey}.
+   * Make a new key with a column family, column qualifier, and column visibility. Copy the
rest of the parts of the key (including delete flag) from
+   * {@code originalKey}.
    */
   protected Key replaceKeyParts(Key originalKey, Text newColFam, Text newColQual, Text newColVis)
{
     byte[] row = originalKey.getRowData().toArray();
@@ -524,18 +476,13 @@ abstract public class KeyTransformingIte
     byte[] cq = newColQual.getBytes();
     byte[] cv = newColVis.getBytes();
     long timestamp = originalKey.getTimestamp();
-    Key newKey = new Key(row, 0, row.length,
-        cf, 0, newColFam.getLength(), 
-        cq, 0, newColQual.getLength(), 
-        cv, 0, newColVis.getLength(),
-        timestamp);
+    Key newKey = new Key(row, 0, row.length, cf, 0, newColFam.getLength(), cq, 0, newColQual.getLength(),
cv, 0, newColVis.getLength(), timestamp);
     newKey.setDeleted(originalKey.isDeleted());
     return newKey;
   }
   
   /**
-   * Make a new key with a column qualifier, and column visibility.  Copy the rest
-   * of the parts of the key (including delete flag) from {@code originalKey}.
+   * Make a new key with a column qualifier, and column visibility. Copy the rest of the
parts of the key (including delete flag) from {@code originalKey}.
    */
   protected Key replaceKeyParts(Key originalKey, Text newColQual, Text newColVis) {
     byte[] row = originalKey.getRowData().toArray();
@@ -543,24 +490,18 @@ abstract public class KeyTransformingIte
     byte[] cq = newColQual.getBytes();
     byte[] cv = newColVis.getBytes();
     long timestamp = originalKey.getTimestamp();
-    Key newKey = new Key(row, 0, row.length,
-        cf, 0, cf.length, 
-        cq, 0, newColQual.getLength(), 
-        cv, 0, newColVis.getLength(),
-        timestamp);
+    Key newKey = new Key(row, 0, row.length, cf, 0, cf.length, cq, 0, newColQual.getLength(),
cv, 0, newColVis.getLength(), timestamp);
     newKey.setDeleted(originalKey.isDeleted());
     return newKey;
   }
   
   /**
-   * Reverses the transformation applied to column families that are fetched at seek
-   * time.  If this iterator is transforming column families, then this method
-   * should be overridden to reverse the transformation on the supplied collection
-   * of column families.  This is necessary since the fetch/seek will be performed
-   * in the transformed space, but when passing the column family set on to the source,
-   * the column families need to be in the untransformed space. 
+   * Reverses the transformation applied to column families that are fetched at seek time.
If this iterator is transforming column families, then this method
+   * should be overridden to reverse the transformation on the supplied collection of column
families. This is necessary since the fetch/seek will be performed
+   * in the transformed space, but when passing the column family set on to the source, the
column families need to be in the untransformed space.
    * 
-   * @param columnFamilies the column families that have been fetched at seek time
+   * @param columnFamilies
+   *          the column families that have been fetched at seek time
    * @return the untransformed column families that would transform info {@code columnFamilies}
    */
   protected Collection<ByteSequence> untransformColumnFamilies(Collection<ByteSequence>
columnFamilies) {
@@ -568,26 +509,21 @@ abstract public class KeyTransformingIte
   }
   
   /**
-   * Indicates the prefix of keys that will be transformed by this iterator.
-   * In other words, this is the part of the key that will <i>not</i> be
-   * transformed by this iterator.  For example, if this method returns
-   * ROW_COLFAM, then {@link #transformKey(Key)} may be changing the
-   * column qualifier, column visibility, or timestamp, but it won't be
-   * changing the row or column family.
-   *  
+   * Indicates the prefix of keys that will be transformed by this iterator. In other words,
this is the part of the key that will <i>not</i> be transformed by
+   * this iterator. For example, if this method returns ROW_COLFAM, then {@link #transformKey(Key)}
may be changing the column qualifier, column visibility, or
+   * timestamp, but it won't be changing the row or column family.
+   * 
    * @return the part of the key this iterator is not transforming
    */
   abstract protected PartialKey getKeyPrefix();
   
   /**
-   * Transforms {@code originalKey}.  This method must not change the row
-   * part of the key, and must only change the parts of the key after the
-   * return value of {@link #getKeyPrefix()}. Implementors must also remember
-   * to copy the delete flag from {@code originalKey} onto the new key.  Or,
-   * implementors should use one of the helper methods to produce the new
-   * key.  See any of the replaceKeyParts methods.
+   * Transforms {@code originalKey}. This method must not change the row part of the key,
and must only change the parts of the key after the return value of
+   * {@link #getKeyPrefix()}. Implementors must also remember to copy the delete flag from
{@code originalKey} onto the new key. Or, implementors should use one
+   * of the helper methods to produce the new key. See any of the replaceKeyParts methods.
    * 
-   * @param originalKey the key to be transformed
+   * @param originalKey
+   *          the key to be transformed
    * @return the modified key
    * @see #replaceColumnFamily(Key, Text)
    * @see #replaceColumnQualifier(Key, Text)

Modified: accumulo/trunk/core/src/test/java/org/apache/accumulo/core/iterators/user/KeyTransformingIteratorTest.java
URL: http://svn.apache.org/viewvc/accumulo/trunk/core/src/test/java/org/apache/accumulo/core/iterators/user/KeyTransformingIteratorTest.java?rev=1434768&r1=1434767&r2=1434768&view=diff
==============================================================================
--- accumulo/trunk/core/src/test/java/org/apache/accumulo/core/iterators/user/KeyTransformingIteratorTest.java
(original)
+++ accumulo/trunk/core/src/test/java/org/apache/accumulo/core/iterators/user/KeyTransformingIteratorTest.java
Thu Jan 17 16:33:47 2013
@@ -91,10 +91,10 @@ public class KeyTransformingIteratorTest
   
   @Test
   public void testIdentityScan() throws Exception {
-    setUpTransformIterator(IdentityKeyTransformingIterator.class); 
+    setUpTransformIterator(IdentityKeyTransformingIterator.class);
     
     // This is just an identity scan, but with the "reuse" iterator that reuses
-    // the same key/value pair for every getTopKey/getTopValue call.  The code
+    // the same key/value pair for every getTopKey/getTopValue call. The code
     // will always return the final key/value if we didn't copy the original key
     // in the iterator.
     TreeMap<Key,Value> expected = new TreeMap<Key,Value>();
@@ -114,7 +114,8 @@ public class KeyTransformingIteratorTest
   @Test
   public void testNoRangeScan() throws Exception {
     @SuppressWarnings("unchecked")
-    List<Class<? extends ReversingKeyTransformingIterator>> classes = Arrays.asList(ColFamReversingKeyTransformingIterator.class,
ColQualReversingKeyTransformingIterator.class, ColVisReversingKeyTransformingIterator.class);
+    List<Class<? extends ReversingKeyTransformingIterator>> classes = Arrays.asList(ColFamReversingKeyTransformingIterator.class,
+        ColQualReversingKeyTransformingIterator.class, ColVisReversingKeyTransformingIterator.class);
     
     // Test transforming col fam, col qual, col vis
     for (Class<? extends ReversingKeyTransformingIterator> clazz : classes) {
@@ -134,14 +135,14 @@ public class KeyTransformingIteratorTest
         }
       }
       
-      checkExpected(expected);    
+      checkExpected(expected);
     }
   }
   
   @Test
   public void testVisbilityFiltering() throws Exception {
     // Should return nothing since we produced visibilities that can't be seen
-    setUpTransformIterator(BadVisKeyTransformingIterator.class);     
+    setUpTransformIterator(BadVisKeyTransformingIterator.class);
     checkExpected(new TreeMap<Key,Value>());
     
     // Do a "reverse" on the visibility (vis1 -> vis2, vis2 -> vis3, vis3 -> vis0)
@@ -159,13 +160,13 @@ public class KeyTransformingIteratorTest
           }
         }
       }
-    }    
+    }
     checkExpected(expected);
   }
   
   @Test
   public void testRangeStart() throws Exception {
-    setUpTransformIterator(ColVisReversingKeyTransformingIterator.class); 
+    setUpTransformIterator(ColVisReversingKeyTransformingIterator.class);
     scanner.setRange(new Range(new Key("row1", "cf2", "cq2", "vis1"), true, new Key("row1",
"cf2", "cq3"), false));
     
     TreeMap<Key,Value> expected = new TreeMap<Key,Value>();
@@ -177,11 +178,11 @@ public class KeyTransformingIteratorTest
   
   @Test
   public void testRangeEnd() throws Exception {
-    setUpTransformIterator(ColVisReversingKeyTransformingIterator.class); 
+    setUpTransformIterator(ColVisReversingKeyTransformingIterator.class);
     scanner.setRange(new Range(new Key("row1", "cf2", "cq2"), true, new Key("row1", "cf2",
"cq2", "vis2"), false));
     
     TreeMap<Key,Value> expected = new TreeMap<Key,Value>();
-    //putExpected(expected, 1, 2, 2, 1, part); // transforms vis outside range end
+    // putExpected(expected, 1, 2, 2, 1, part); // transforms vis outside range end
     putExpected(expected, 1, 2, 2, 2, PartialKey.ROW_COLFAM_COLQUAL);
     putExpected(expected, 1, 2, 2, 3, PartialKey.ROW_COLFAM_COLQUAL);
     
@@ -191,7 +192,7 @@ public class KeyTransformingIteratorTest
   @Test
   public void testPrefixRange() throws Exception {
     setUpTransformIterator(ColFamReversingKeyTransformingIterator.class);
-    // Set a range that is before all of the untransformed data.  However,
+    // Set a range that is before all of the untransformed data. However,
     // the data with untransformed col fam cf3 will transform to cf0 and
     // be inside the range.
     scanner.setRange(new Range(new Key("row1", "cf0"), true, new Key("row1", "cf1"), false));
@@ -219,25 +220,25 @@ public class KeyTransformingIteratorTest
     originalKey.setDeleted(true);
     
     Key newKey = it.replaceColumnFamily(originalKey, new Text("test"));
-    assertEquals(createDeleteKey("r","test","cq","cv",42), newKey);
+    assertEquals(createDeleteKey("r", "test", "cq", "cv", 42), newKey);
     
     newKey = it.replaceColumnQualifier(originalKey, new Text("test"));
-    assertEquals(createDeleteKey("r","cf","test","cv",42), newKey);
+    assertEquals(createDeleteKey("r", "cf", "test", "cv", 42), newKey);
     
     newKey = it.replaceColumnVisibility(originalKey, new Text("test"));
-    assertEquals(createDeleteKey("r","cf","cq","test",42), newKey);
+    assertEquals(createDeleteKey("r", "cf", "cq", "test", 42), newKey);
     
     newKey = it.replaceKeyParts(originalKey, new Text("testCQ"), new Text("testCV"));
-    assertEquals(createDeleteKey("r","cf","testCQ","testCV",42), newKey);
+    assertEquals(createDeleteKey("r", "cf", "testCQ", "testCV", 42), newKey);
     
     newKey = it.replaceKeyParts(originalKey, new Text("testCF"), new Text("testCQ"), new
Text("testCV"));
-    assertEquals(createDeleteKey("r","testCF","testCQ","testCV",42), newKey);
+    assertEquals(createDeleteKey("r", "testCF", "testCQ", "testCV", 42), newKey);
   }
   
   @Test
   public void testFetchColumnFamilites() throws Exception {
     // In this test, we are fetching column family cf2, which is in
-    // the transformed space.  The source column family that will
+    // the transformed space. The source column family that will
     // transform into cf2 is cf1, so that is the column family we
     // put in the expectations.
     int expectedCF = 1;
@@ -260,7 +261,7 @@ public class KeyTransformingIteratorTest
   @Test
   public void testCompactionScanFetchingColumnFamilies() throws Exception {
     // In this test, we are fetching column family cf2, which is in
-    // the transformed space.  The source column family that will
+    // the transformed space. The source column family that will
     // transform into cf2 is cf1, so that is the column family we
     // put in the expectations.
     int expectedCF = 1;
@@ -273,15 +274,15 @@ public class KeyTransformingIteratorTest
         for (int cv = 1; cv <= 3; ++cv)
           putExpected(expected, row, expectedCF, cq, cv, PartialKey.ROW);
     checkExpected(expected);
-  }  
+  }
   
   @Test
   public void testCompactionDoesntFilterVisibilities() throws Exception {
     // In scan mode, this should return nothing since it produces visibilites
-    // the user can't see.  In compaction mode, however, the visibilites
+    // the user can't see. In compaction mode, however, the visibilites
     // should still show up.
-    setUpTransformIterator(BadVisCompactionKeyTransformingIterator.class);     
-
+    setUpTransformIterator(BadVisCompactionKeyTransformingIterator.class);
+    
     TreeMap<Key,Value> expected = new TreeMap<Key,Value>();
     for (int rowID = 1; rowID <= 3; ++rowID) {
       for (int cfID = 1; cfID <= 3; ++cfID) {
@@ -291,7 +292,7 @@ public class KeyTransformingIteratorTest
             String cf = "cf" + cfID;
             String cq = "cq" + cqID;
             String cv = "badvis";
-            long ts = 100*cfID + 10*cqID + cvID;
+            long ts = 100 * cfID + 10 * cqID + cvID;
             String val = "val" + ts;
             expected.put(new Key(row, cf, cq, cv, ts), new Value(val.getBytes()));
           }
@@ -299,7 +300,7 @@ public class KeyTransformingIteratorTest
       }
     }
     
-    checkExpected(expected);    
+    checkExpected(expected);
   }
   
   private Key createDeleteKey(String row, String colFam, String colQual, String colVis, long
timestamp) {
@@ -327,17 +328,20 @@ public class KeyTransformingIteratorTest
     String cf = "cf" + cfID;
     String cq = "cq" + cqID;
     String cv = "vis" + cvID;
-    long ts = 100*cfID + 10*cqID + cvID;
+    long ts = 100 * cfID + 10 * cqID + cvID;
     String val = "val" + ts;
     
     if (part != null) {
       switch (part) {
         case ROW:
-          cf = transform(new Text(cf)).toString(); break;
+          cf = transform(new Text(cf)).toString();
+          break;
         case ROW_COLFAM:
-          cq = transform(new Text(cq)).toString(); break;
+          cq = transform(new Text(cq)).toString();
+          break;
         case ROW_COLFAM_COLQUAL:
-          cv = transform(new Text(cv)).toString(); break;
+          cv = transform(new Text(cv)).toString();
+          break;
         default:
           break;
       }
@@ -349,7 +353,7 @@ public class KeyTransformingIteratorTest
   private static Text transform(Text val) {
     String s = val.toString();
     // Reverse the order of the number at the end, and subtract one
-    int i = 3 - Integer.parseInt(s.substring(s.length()-1));
+    int i = 3 - Integer.parseInt(s.substring(s.length() - 1));
     StringBuilder sb = new StringBuilder();
     sb.append(s.substring(0, s.length() - 1));
     sb.append(i);
@@ -364,7 +368,7 @@ public class KeyTransformingIteratorTest
           String cf = "cf" + cfID;
           String cq = "cq" + cqID;
           String cv = "vis" + cvID;
-          long ts = 100*cfID + 10*cqID + cvID;
+          long ts = 100 * cfID + 10 * cqID + cvID;
           String val = "val" + ts;
           
           m.put(cf, cq, new ColumnVisibility(cv), ts, val);
@@ -382,11 +386,14 @@ public class KeyTransformingIteratorTest
     long ts = originalKey.getTimestamp();
     switch (part) {
       case ROW:
-        cf = transform(cf); break;
+        cf = transform(cf);
+        break;
       case ROW_COLFAM:
-        cq = transform(cq); break;
+        cq = transform(cq);
+        break;
       case ROW_COLFAM_COLQUAL:
-        cv = transform(cv); break;
+        cv = transform(cv);
+        break;
       default:
         break;
     }
@@ -421,7 +428,7 @@ public class KeyTransformingIteratorTest
     @Override
     protected Collection<ByteSequence> untransformColumnFamilies(Collection<ByteSequence>
columnFamilies) {
       HashSet<ByteSequence> untransformed = new HashSet<ByteSequence>();
-      for (ByteSequence cf : columnFamilies) 
+      for (ByteSequence cf : columnFamilies)
         untransformed.add(untransformColumnFamily(cf));
       return untransformed;
     }
@@ -515,23 +522,23 @@ public class KeyTransformingIteratorTest
     public MajCIteratorEnvironmentAdapter(IteratorEnvironment delegate) {
       this.delegate = delegate;
     }
-
+    
     public SortedKeyValueIterator<Key,Value> reserveMapFileReader(String mapFileName)
throws IOException {
       return delegate.reserveMapFileReader(mapFileName);
     }
-
+    
     public AccumuloConfiguration getConfig() {
       return delegate.getConfig();
     }
-
+    
     public IteratorScope getIteratorScope() {
       return IteratorScope.majc;
     }
-
+    
     public boolean isFullMajorCompaction() {
       return delegate.isFullMajorCompaction();
     }
-
+    
     public void registerSideChannel(SortedKeyValueIterator<Key,Value> iter) {
       delegate.registerSideChannel(iter);
     }



Mime
View raw message