Method fetchCollisions

src/tree/Tree.java:634–701

Returns the collision set from storage for the given tree, optionally for only the list of TSUIDs provided. Note: This can potentially be a large list if the rule set was written poorly and there were many timeseries so only call this without a list of TSUIDs if you feel confident the number

(final TSDB tsdb, 
      final int tree_id, final List<String> tsuids)

   * @throws IllegalArgumentException if the tree ID was invalid
   */
  public static Deferred<Map<String, String>> fetchCollisions(final TSDB tsdb, 
      final int tree_id, final List<String> tsuids) {
    if (tree_id < 1 || tree_id > 65535) {
      throw new IllegalArgumentException("Invalid Tree ID");
    }
    
    final byte[] row_key = new byte[TREE_ID_WIDTH + 1];
    System.arraycopy(idToBytes(tree_id), 0, row_key, 0, TREE_ID_WIDTH);
    row_key[TREE_ID_WIDTH] = COLLISION_ROW_SUFFIX;
    
    final GetRequest get = new GetRequest(tsdb.treeTable(), row_key);
    get.family(TREE_FAMILY);
    
    // if the caller provided a list of TSUIDs, then we need to compile a list
    // of qualifiers so we only fetch those columns.
    if (tsuids != null && !tsuids.isEmpty()) {
      final byte[][] qualifiers = new byte[tsuids.size()][];
      int index = 0;
      for (String tsuid : tsuids) {
        final byte[] qualifier = new byte[COLLISION_PREFIX.length + 
                                          (tsuid.length() / 2)];
        System.arraycopy(COLLISION_PREFIX, 0, qualifier, 0, 
            COLLISION_PREFIX.length);
        final byte[] tsuid_bytes = UniqueId.stringToUid(tsuid);
        System.arraycopy(tsuid_bytes, 0, qualifier, COLLISION_PREFIX.length, 
            tsuid_bytes.length);
        qualifiers[index] = qualifier;
        index++;
      }
      get.qualifiers(qualifiers);
    }
    
    /**
     * Called after issuing the row get request to parse out the results and
     * compile the list of collisions.
     */
    final class GetCB implements Callback<Deferred<Map<String, String>>, 
      ArrayList<KeyValue>> {

      @Override
      public Deferred<Map<String, String>> call(final ArrayList<KeyValue> row)
          throws Exception {
        if (row == null || row.isEmpty()) {
          final Map<String, String> empty = new HashMap<String, String>(0);
          return Deferred.fromResult(empty);
        }
        
        final Map<String, String> collisions = 
          new HashMap<String, String>(row.size());
        
        for (KeyValue column : row) {
          if (column.qualifier().length > COLLISION_PREFIX.length && 
              Bytes.memcmp(COLLISION_PREFIX, column.qualifier(), 0, 
                  COLLISION_PREFIX.length) == 0) {
            final byte[] parsed_tsuid = Arrays.copyOfRange(column.qualifier(), 
                COLLISION_PREFIX.length, column.qualifier().length);
            collisions.put(UniqueId.uidToString(parsed_tsuid), 
                new String(column.value(), CHARSET));