Java CompareOp.GREATER属性代码示例

public static Range[] fromFilter(SingleColumnValueFilter filter) {
  if (!(filter.getComparator() instanceof BinaryComparator)) {
    return new Range[0];
  }

  byte[] column = KeyValue.makeColumn(filter.getFamily(), filter.getQualifier());
  CompareOp compareOp = filter.getOperator();
  byte[] value = filter.getComparator().getValue();

  if (compareOp == CompareOp.NOT_EQUAL) {
    return new Range[] { new Range(column, null, CompareOp.NO_OP, value, CompareOp.LESS),
        new Range(column, value, CompareOp.GREATER, null, CompareOp.NO_OP) };
  } else {
    switch (compareOp) {
    case EQUAL:
    case GREATER_OR_EQUAL:
    case GREATER:
      return new Range[] { new Range(column, value, compareOp, null, CompareOp.NO_OP) };
    case LESS:
    case LESS_OR_EQUAL:
      return new Range[] { new Range(column, null, CompareOp.NO_OP, value, compareOp) };
    default:
      return new Range[0];
    }
  }
}
 

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

@Test
  public void testFilterWithLongCompartor() throws Exception {
    byte [] TABLE = Bytes.toBytes("testFilterWithLongCompartor");
    Table ht = TEST_UTIL.createTable(TABLE, 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.add(FAMILY, QUALIFIER, values[i]);
      ht.put(put);
    }
    Scan scan = new Scan();
    scan.addFamily(FAMILY);
    Filter filter = new SingleColumnValueFilter(FAMILY, QUALIFIER, CompareOp.GREATER,
      new LongComparator(500));
    scan.setFilter(filter);
    ResultScanner scanner = ht.getScanner(scan);
    int expectedIndex = 0;
    for(Result result : ht.getScanner(scan)) {
      assertEquals(result.size(), 1);
      assertTrue(Bytes.toLong(result.getValue(FAMILY, QUALIFIER)) > 500);
      expectedIndex++;
    }
    assertEquals(expectedIndex, 4);
    scanner.close();
}
 

/**
 * Set end type for end value.
 * @param stopType - can only be LESS , LESS_OR_EQUAL or NO_OP
 */
public void setStopType(CompareOp stopType) {
  if (stopType == CompareOp.EQUAL || stopType == CompareOp.GREATER
      || stopType == CompareOp.GREATER_OR_EQUAL || stopType == CompareOp.NOT_EQUAL) {
    throw new IllegalArgumentException("Illegal end type: " + stopType.toString());
  }

  this.stopType = stopType;
}
 

/**
 * Set start type for start value.
 *
 * @param startType - can only be EQUAL, GREATER or GREATER_OR_EQUAL
 */
public void setStartType(CompareOp startType) {
  if (startType == CompareOp.EQUAL || startType == CompareOp.GREATER
      || startType == CompareOp.GREATER_OR_EQUAL) {
    this.startType = startType;
  } else {
    this.startType = startType;
    //			throw new IllegalArgumentException("Illegal start type: "
    //					+ startType.toString());
  }
}
 

public Range getOpsite() {
  Range ran = new Range();
  ran.column = this.column;
  ran.valueType = this.valueType;
  ran.startValue = this.endValue;
  ran.endValue = this.startValue;
  ran.setStartTs(startTs);
  ran.setEndTs(endTs);
  ran.setLatestVersionOnly(latestVersionOnly);
  ran.setFilterIfMissing(filterIfMissing);

  if (ran.valueType == DataType.BOOLEAN) {
    if (Bytes.toString(this.startValue).equals("true")) {
      ran.startValue = Bytes.toBytes("false");
    } else if (Bytes.toString(this.startValue).equals("false")) {
      ran.startValue = Bytes.toBytes("true");
    }
    ran.startType = CompareOp.EQUAL;
    return ran;
  }
  if (this.startValue != null && this.startValue.length != 0) {
    switch (this.startType) {
    case EQUAL:
      ran.startType = CompareOp.GREATER;
      ran.startValue = this.startValue;
      ran.endValue = this.startValue;
      ran.endType = CompareOp.LESS;
      break;
    case GREATER_OR_EQUAL:
      ran.endType = CompareOp.LESS;
      break;
    case GREATER:
      ran.endType = CompareOp.LESS_OR_EQUAL;
      break;
    default:
      break;
    }
  }
  if (this.endValue != null && this.endValue.length != 0) {
    switch (this.endType) {
    case LESS:
      ran.startType = CompareOp.GREATER_OR_EQUAL;
      break;
    case LESS_OR_EQUAL:
      ran.startType = CompareOp.GREATER;
      break;
    default:
      break;
    }
  }

  return ran;
}