org.apache.hadoop.hbase.CompareOperator#GREATER源码实例Demo

protected CompareOperator getCompare(Where where) {
    if (where == Where.Equals)
        return CompareOperator.EQUAL;

    if (where == Where.NotEquals)
        return CompareOperator.NOT_EQUAL;

    if (where == Where.Less)
        return CompareOperator.LESS;

    if (where == Where.LessEquals)
        return CompareOperator.LESS_OR_EQUAL;

    if (where == Where.Greater)
        return CompareOperator.GREATER;

    if (where == Where.GreaterEquals)
        return CompareOperator.GREATER_OR_EQUAL;

    return CompareOperator.EQUAL;
}
 

/**
 * Takes a compareOperator symbol as a byte array and returns the corresponding CompareOperator
 * @param compareOpAsByteArray the comparatorOperator symbol as a byte array
 * @return the Compare Operator
 */
public static CompareOperator createCompareOperator (byte [] compareOpAsByteArray) {
  ByteBuffer compareOp = ByteBuffer.wrap(compareOpAsByteArray);
  if (compareOp.equals(ParseConstants.LESS_THAN_BUFFER))
    return CompareOperator.LESS;
  else if (compareOp.equals(ParseConstants.LESS_THAN_OR_EQUAL_TO_BUFFER))
    return CompareOperator.LESS_OR_EQUAL;
  else if (compareOp.equals(ParseConstants.GREATER_THAN_BUFFER))
    return CompareOperator.GREATER;
  else if (compareOp.equals(ParseConstants.GREATER_THAN_OR_EQUAL_TO_BUFFER))
    return CompareOperator.GREATER_OR_EQUAL;
  else if (compareOp.equals(ParseConstants.NOT_EQUAL_TO_BUFFER))
    return CompareOperator.NOT_EQUAL;
  else if (compareOp.equals(ParseConstants.EQUAL_TO_BUFFER))
    return CompareOperator.EQUAL;
  else
    throw new IllegalArgumentException("Invalid compare operator");
}
 

public static CompareOperator compareOpFromThrift(TCompareOperator tCompareOp) {
  switch (tCompareOp.getValue()) {
    case 0: return CompareOperator.LESS;
    case 1: return CompareOperator.LESS_OR_EQUAL;
    case 2: return CompareOperator.EQUAL;
    case 3: return CompareOperator.NOT_EQUAL;
    case 4: return CompareOperator.GREATER_OR_EQUAL;
    case 5: return CompareOperator.GREATER;
    case 6: return CompareOperator.NO_OP;
    default: return null;
  }
}
 

@Test public void testFilterWithLongCompartor() throws Exception {
  final TableName tableName = name.getTableName();
  try (Table ht = TEST_UTIL.createTable(tableName, FAMILY)) {
    byte[][] ROWS = makeN(ROW, 10);
    byte[][] values = new byte[10][];
    for (int i = 0; i < 10; i++) {
      values[i] = Bytes.toBytes(100L * i);
    }
    for (int i = 0; i < 10; i++) {
      Put put = new Put(ROWS[i]);
      put.setDurability(Durability.SKIP_WAL);
      put.addColumn(FAMILY, QUALIFIER, values[i]);
      ht.put(put);
    }
    Scan scan = new Scan();
    scan.addFamily(FAMILY);
    Filter filter = new SingleColumnValueFilter(FAMILY, QUALIFIER, CompareOperator.GREATER,
      new LongComparator(500));
    scan.setFilter(filter);
    try (ResultScanner scanner = ht.getScanner(scan)) {
      int expectedIndex = 0;
      for (Result result : scanner) {
        assertEquals(1, result.size());
        assertTrue(Bytes.toLong(result.getValue(FAMILY, QUALIFIER)) > 500);
        expectedIndex++;
      }
      assertEquals(4, expectedIndex);
    }
  }
}
 

private void setRowFilters(FilterList filterList) {
  //offset for b as it is second component of "a+b+c+d"
  //'a' is at offset 0
  int bOffset = 4;
  byte[] b10 = Bytes.toBytes(10); //tests b > 10
  Filter b10Filter = new RowFilter(CompareOperator.GREATER,
          new BinaryComponentComparator(b10,bOffset));
  filterList.addFilter(b10Filter);

  byte[] b20  = Bytes.toBytes(20); //tests b < 20
  Filter b20Filter = new RowFilter(CompareOperator.LESS,
          new BinaryComponentComparator(b20,bOffset));
  filterList.addFilter(b20Filter);

  //offset for c as it is third component of "a+b+c+d"
  int cOffset = 8;
  byte[] c90  = Bytes.toBytes(90); //tests c > 90
  Filter c90Filter = new RowFilter(CompareOperator.GREATER,
          new BinaryComponentComparator(c90,cOffset));
  filterList.addFilter(c90Filter);

  byte[] c100  = Bytes.toBytes(100); //tests c < 100
  Filter c100Filter = new RowFilter(CompareOperator.LESS,
          new BinaryComponentComparator(c100,cOffset));
  filterList.addFilter(c100Filter);

  //offset for d as it is fourth component of "a+b+c+d"
  int dOffset = 12;
  byte[] d1   = Bytes.toBytes(1); //tests d == 1
  Filter dFilter  = new RowFilter(CompareOperator.EQUAL,
          new BinaryComponentComparator(d1,dOffset));

  filterList.addFilter(dFilter);

}