docs: @VisibleForTesting
      ByteMap<ByteMap<List<GetRequest>>> prepareRequestsNoMeta(final List<byte[][]> tagv_compounds, 
          final List<Long> base_time_list) {
        
        final int row_size = (Const.SALT_WIDTH() + tsdb.metrics.width() 
            + Const.TIMESTAMP_BYTES
            + (tsdb.tag_names.width() * tags.get(0).size()) 
            + (tsdb.tag_values.width() * tags.get(0).size()));
  
        final ByteMap<List<GetRequest>> tsuid_rows = new ByteMap<List<GetRequest>>();
        for (final byte[][] tagvs : tagv_compounds) {
          // TSUID's don't have salts
          // TODO: we reallly don't have to allocate tsuid's here.
          // we can use the row_key array to fetch the tsuid.
          // This will just double the memory utilization per time series.
          final byte[] tsuid = new byte[tsdb.metrics.width() 
              + (tags.get(0).size() * tsdb.tag_names.width())
              + tags.get(0).size() * tsdb.tag_values.width()];
          final byte[] row_key = new byte[row_size];
          
          // metric
          System.arraycopy(metric, 0, row_key, Const.SALT_WIDTH(), tsdb.metrics.width());
          System.arraycopy(metric, 0, tsuid, 0, tsdb.metrics.width());
          
          final List<GetRequest> rows = 
              new ArrayList<GetRequest>(base_time_list.size());
          
          // copy tagks and tagvs to the row key
          int tag_index = 0;
          int row_key_copy_offset = Const.SALT_WIDTH() + tsdb.metrics.width() 
            + Const.TIMESTAMP_BYTES;
          int tsuid_copy_offset = tsdb.metrics.width();
          for (Map.Entry<byte[], byte[][]> tag : tags.get(0)) {
            // tagk
            byte[] tagk = tag.getKey();
            System.arraycopy(tagk, 0, row_key, row_key_copy_offset, tsdb.tag_names.width());
            System.arraycopy(tagk, 0, tsuid, tsuid_copy_offset, tsdb.tag_names.width());
            row_key_copy_offset += tsdb.tag_names.width();
            tsuid_copy_offset += tsdb.tag_names.width();
  
            // tagv
            System.arraycopy(tagvs[tag_index], 0, row_key, row_key_copy_offset, 
                tsdb.tag_values.width());
            System.arraycopy(tagvs[tag_index], 0, tsuid, tsuid_copy_offset, 
                tsdb.tag_values.width());
            row_key_copy_offset += tsdb.tag_values.width();
            tsuid_copy_offset += tsdb.tag_values.width();
  
            // move to the next tag
            ++tag_index;
          }
          
          // iterate for each timestamp, making a copy of the key and tweaking it's 
          // timestamp.
          for (final long row_base_time : base_time_list) {
            final byte[] key_copy = Arrays.copyOf(row_key, row_key.length);
            
            // base time
            Internal.setBaseTime(key_copy, (int) row_base_time);
            
            if (get_all_salts) {
              for (int i = 0; i < Const.SALT_BUCKETS(); i++) {
                final byte[] copy = Arrays.copyOf(key_copy, key_copy.length);
                // TODO - handle multi byte salts
                copy[0] = (byte) i;
                rows.add(new GetRequest(table_to_fetch, copy, TSDB.FAMILY));
              }
            } else {
              // salt
              RowKey.prefixKeyWithSalt(key_copy);
              rows.add(new GetRequest(table_to_fetch, key_copy, TSDB.FAMILY));
            }
          } // end for
          
          tsuid_rows.put(tsuid, rows);
        } // end for
        ByteMap<ByteMap<List<GetRequest>>> return_obj = new ByteMap<ByteMap<List<GetRequest>>>();
     //   byte[] salt = new byte[Const.SALT_WIDTH()];
       // System.arraycopy("1".getBytes(), 0, salt, 0, Const.SALT_WIDTH());
        return_obj.put("0".getBytes(), tsuid_rows);
         return return_obj;
      }