Method bufferMultiColumnAtomicIncrement

src/HBaseClient.java:1736–1772

Buffers a durable atomic increment for coalescing. This increment will be held in memory up to the amount of time allowed by #getFlushInterval in order to allow the client to coalesce increments. Increment coalescing can dramatically reduce the number of RPCs and write load on HBase

(final MultiColumnAtomicIncrementRequest request)

   * @since 1.4 This method works with negative increment values.
   */
  public Deferred<Map<byte[], Long>> bufferMultiColumnAtomicIncrement(final MultiColumnAtomicIncrementRequest request) {

    if (flush_interval == 0) { // Client-side buffer disabled.
      return atomicIncrement(request);
    }

    long[] values = request.getAmounts();
    for(long value: values) {
      if (!BufferedIncrement.Amount.checkOverflow(value)) {   // Value too large
        return atomicIncrement(request);
      }
    }

    final BufferedMultiColumnIncrement incr = new BufferedMultiColumnIncrement(request.table(), request.key(), request.family(),
                            request.qualifiers());

    do {
      BufferedMultiColumnIncrement.Amounts amounts;
      // Semi-evil: the very first time we get here, `increment_buffer' will
      // still be null (we don't initialize it in our constructor) so we catch
      // the NPE that ensues to allocate the buffer and kick off a timer to
      // regularly flush it.
      try {
        amounts = multi_column_increment_buffer.getUnchecked(incr);
      } catch (NullPointerException e) {
        setupMultiColumnIncrementCoalescing();
        amounts = multi_column_increment_buffer.getUnchecked(incr);
      }
      if (amounts.update(values)) {
        final Deferred<Map<byte[], Long>> deferred = new Deferred<Map<byte[], Long>>();
        amounts.deferred.chain(deferred);
        return deferred;
      }
      // else: Loop again to retry.
      multi_column_increment_buffer.refresh(incr);
    } while (true);
  }

  /**
   * Called the first time we get a buffered increment.