Method parseKeyValue

src/core/AppendDataPoints.java:118–236

Parses a column from storage, orders and drops newer duplicate data points. The parsing will return both a Cell collection for debugging and add the cells to concatenated qualifier and value arrays in the compacted data point format so that the results can be merged with other non-append columns or

(final TSDB tsdb, final KeyValue kv)

   * or we were unable to parse the value.
   */
  public final Collection<Cell> parseKeyValue(final TSDB tsdb, final KeyValue kv) {
    if (kv.qualifier().length != 3 || kv.qualifier()[0] != APPEND_COLUMN_PREFIX) {
      // it's really not an issue if the offset is not 0, maybe in the future
      // we'll support appends at different offsets.
      throw new IllegalArgumentException("Can not parse cell, it is not " +
        " an appended cell. It has a different qualifier " + 
        Bytes.pretty(kv.qualifier()) + ", row key " + Bytes.pretty(kv.key()));
    }
    final boolean repair = tsdb.getConfig().repair_appends();
    final long base_time;
    try {
      base_time = Internal.baseTime(tsdb, kv.key());
    } catch (ArrayIndexOutOfBoundsException oob) {
      throw new IllegalDataException("Corrupted value: invalid row key: " + kv, 
          oob);
    }

    int val_idx = 0;
    int val_length = 0;
    int qual_length = 0;
    int last_delta = -1;  // Time delta, extracted from the qualifier.
    
    final Map<Integer, Internal.Cell> deltas = new TreeMap<Integer, Cell>();
    boolean has_duplicates = false;
    boolean out_of_order = false;
    boolean needs_repair = false;
    
    try {
      while (val_idx < kv.value().length) {
        byte[] q = Internal.extractQualifier(kv.value(), val_idx);
        System.arraycopy(kv.value(), val_idx, q, 0, q.length);
        val_idx=val_idx + q.length;
        
        int vlen = Internal.getValueLengthFromQualifier(q, 0);
        byte[] v = new byte[vlen];
        System.arraycopy(kv.value(), val_idx, v, 0, vlen);
        val_idx += vlen;
        int delta = Internal.getOffsetFromQualifier(q);
    
        final Cell duplicate = deltas.get(delta);
        if (duplicate != null) {
          // This is a duplicate cell, skip it
          has_duplicates = true;
          qual_length -= duplicate.qualifier.length;
          val_length -= duplicate.value.length;
        }
  
        qual_length += q.length;
        val_length += vlen;
        final Cell cell = new Cell(q, v);
        deltas.put(delta, cell);
  
        if (!out_of_order) {
          // Data points needs to be sorted if we find at least one out of 
          // order data
          if (delta <= last_delta) {
            out_of_order = true;
          }