Java ByteArrayComparable.compareTo方法代码示例

import org.apache.hadoop.hbase.filter.ByteArrayComparable; //导入方法依赖的package包/类
/**
 * Compare cell's row against given comparator
 * @param cell
 * @param comparator
 * @return result comparing cell's row
 */
public static int compareRow(Cell cell, ByteArrayComparable comparator) {
  if (cell instanceof ByteBufferExtendedCell) {
    return comparator.compareTo(((ByteBufferExtendedCell) cell).getRowByteBuffer(),
      ((ByteBufferExtendedCell) cell).getRowPosition(), cell.getRowLength());
  }
  return comparator.compareTo(cell.getRowArray(), cell.getRowOffset(), cell.getRowLength());
}
 

import org.apache.hadoop.hbase.filter.ByteArrayComparable; //导入方法依赖的package包/类
/**
 * Compare cell's column family against given comparator
 * @param cell
 * @param comparator
 * @return result comparing cell's column family
 */
public static int compareFamily(Cell cell, ByteArrayComparable comparator) {
  if (cell instanceof ByteBufferExtendedCell) {
    return comparator.compareTo(((ByteBufferExtendedCell) cell).getFamilyByteBuffer(),
      ((ByteBufferExtendedCell) cell).getFamilyPosition(), cell.getFamilyLength());
  }
  return comparator.compareTo(cell.getFamilyArray(), cell.getFamilyOffset(),
    cell.getFamilyLength());
}
 

import org.apache.hadoop.hbase.filter.ByteArrayComparable; //导入方法依赖的package包/类
/**
 * Compare cell's qualifier against given comparator
 * @param cell
 * @param comparator
 * @return result comparing cell's qualifier
 */
public static int compareQualifier(Cell cell, ByteArrayComparable comparator) {
  if (cell instanceof ByteBufferExtendedCell) {
    return comparator.compareTo(((ByteBufferExtendedCell) cell).getQualifierByteBuffer(),
      ((ByteBufferExtendedCell) cell).getQualifierPosition(), cell.getQualifierLength());
  }
  return comparator.compareTo(cell.getQualifierArray(), cell.getQualifierOffset(),
    cell.getQualifierLength());
}
 

import org.apache.hadoop.hbase.filter.ByteArrayComparable; //导入方法依赖的package包/类
/**
 * Compare cell's value against given comparator
 * @param cell
 * @param comparator
 * @return result comparing cell's value
 */
public static int compareValue(Cell cell, ByteArrayComparable comparator) {
  if (cell instanceof ByteBufferExtendedCell) {
    return comparator.compareTo(((ByteBufferExtendedCell) cell).getValueByteBuffer(),
      ((ByteBufferExtendedCell) cell).getValuePosition(), cell.getValueLength());
  }
  return comparator.compareTo(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength());
}
 

import org.apache.hadoop.hbase.filter.ByteArrayComparable; //导入方法依赖的package包/类
/**
 * @return true if the new put was executed, false otherwise
 * @throws IOException
 */
public boolean checkAndRowMutate(byte[] row, byte[] family, byte[] qualifier,
                                 CompareOp compareOp, ByteArrayComparable comparator, RowMutations rm,
                                 boolean writeToWAL)
        throws IOException {
    checkReadOnly();
    //TODO, add check for value length or maybe even better move this to the
    //client if this becomes a global setting
    checkResources();

    startRegionOperation();
    try {
        Get get = new Get(row);
        checkFamily(family);
        get.addColumn(family, qualifier);

        // Lock row - note that doBatchMutate will relock this row if called
        RowLock rowLock = getRowLock(get.getRow());
        // wait for all previous transactions to complete (with lock held)
        mvcc.waitForPreviousTransactionsComplete();
        try {
            List<Cell> result = get(get, false);

            boolean valueIsNull = comparator.getValue() == null ||
                    comparator.getValue().length == 0;
            boolean matches = false;
            if (result.size() == 0 && valueIsNull) {
                matches = true;
            } else if (result.size() > 0 && result.get(0).getValueLength() == 0 &&
                    valueIsNull) {
                matches = true;
            } else if (result.size() == 1 && !valueIsNull) {
                Cell kv = result.get(0);
                int compareResult = comparator.compareTo(kv.getValueArray(),
                        kv.getValueOffset(), kv.getValueLength());
                switch (compareOp) {
                    case LESS:
                        matches = compareResult < 0;
                        break;
                    case LESS_OR_EQUAL:
                        matches = compareResult <= 0;
                        break;
                    case EQUAL:
                        matches = compareResult == 0;
                        break;
                    case NOT_EQUAL:
                        matches = compareResult != 0;
                        break;
                    case GREATER_OR_EQUAL:
                        matches = compareResult >= 0;
                        break;
                    case GREATER:
                        matches = compareResult > 0;
                        break;
                    default:
                        throw new RuntimeException("Unknown Compare op " + compareOp.name());
                }
            }
            //If matches put the new put or delete the new delete
            if (matches) {
                // All edits for the given row (across all column families) must
                // happen atomically.
                mutateRow(rm);
                this.checkAndMutateChecksPassed.increment();
                return true;
            }
            this.checkAndMutateChecksFailed.increment();
            return false;
        } finally {
            rowLock.release();
        }
    } finally {
        closeRegionOperation();
    }
}