Java 类org.apache.hadoop.hbase.filter.QualifierFilter 实例源码

项目：cloud-bigtable-client 文件：QualifierFilterAdapter.java

@Override
public FilterSupportStatus isFilterSupported(
    FilterAdapterContext context, QualifierFilter filter) {
  // For range filters, we only support a single family:
  if (!CompareOp.EQUAL.equals(filter.getOperator())
      && filter.getComparator() instanceof BinaryComparator
      && context.getScan().numFamilies() != 1) {
    return SINGLE_FAMILY_REQUIRED;
  }
  // Support binary comparators and regex comparators with equal compare op:
  if ( !(filter.getComparator() instanceof BinaryComparator)
      && !isRegexAndSupported(filter)) {
    return UNSUPPORTED_COMPARABLE;
  }
  return FilterSupportStatus.SUPPORTED;
}

项目：hbase 文件：TestScannersFromClientSide.java

@Test
public void testScanWithColumnsAndFilterAndVersion() throws IOException {
  TableName tableName = TableName.valueOf(name.getMethodName());
  try (Table table = TEST_UTIL.createTable(tableName, FAMILY, 4)) {
    for (int i = 0; i < 4; i++) {
      Put put = new Put(ROW);
      put.addColumn(FAMILY, QUALIFIER, VALUE);
      table.put(put);
    }

    Scan scan = new Scan();
    scan.addColumn(FAMILY, QUALIFIER);
    scan.setFilter(new QualifierFilter(CompareOperator.EQUAL, new BinaryComparator(QUALIFIER)));
    scan.readVersions(3);

    try (ResultScanner scanner = table.getScanner(scan)) {
      Result result = scanner.next();
      assertEquals(3, result.size());
    }
  }
}

项目：pinpoint 文件：HbaseApplicationTraceIndexDao.java

/**
 * make the hbase filter for selecting values of y-axis(response time) in order to select transactions in scatter chart.
 * 4 bytes for elapsed time should be attached for the prefix of column qualifier for to use this filter.
 *
 * @param area
 * @param offsetTransactionId
 * @param offsetTransactionElapsed
 * @return
 */
private Filter makeResponseTimeFilter(final SelectedScatterArea area, final TransactionId offsetTransactionId, int offsetTransactionElapsed) {
    // filter by response time
    ResponseTimeRange responseTimeRange = area.getResponseTimeRange();
    byte[] responseFrom = Bytes.toBytes(responseTimeRange.getFrom());
    byte[] responseTo = Bytes.toBytes(responseTimeRange.getTo());
    FilterList filterList = new FilterList(Operator.MUST_PASS_ALL);
    filterList.addFilter(new QualifierFilter(CompareOp.GREATER_OR_EQUAL, new BinaryPrefixComparator(responseFrom)));
    filterList.addFilter(new QualifierFilter(CompareOp.LESS_OR_EQUAL, new BinaryPrefixComparator(responseTo)));

    // add offset
    if (offsetTransactionId != null) {
        final Buffer buffer = new AutomaticBuffer(32);
        buffer.putInt(offsetTransactionElapsed);
        buffer.putPrefixedString(offsetTransactionId.getAgentId());
        buffer.putSVLong(offsetTransactionId.getAgentStartTime());
        buffer.putVLong(offsetTransactionId.getTransactionSequence());
        byte[] qualifierOffset = buffer.getBuffer();

        filterList.addFilter(new QualifierFilter(CompareOp.GREATER, new BinaryPrefixComparator(qualifierOffset)));
    }
    return filterList;
}

项目：ditb 文件：TestFromClientSide.java

@Test
public void testFilters() throws Exception {
  byte [] TABLE = Bytes.toBytes("testFilters");
  Table ht = TEST_UTIL.createTable(TABLE, FAMILY);
  byte [][] ROWS = makeN(ROW, 10);
  byte [][] QUALIFIERS = {
      Bytes.toBytes("col0-<d2v1>-<d3v2>"), Bytes.toBytes("col1-<d2v1>-<d3v2>"),
      Bytes.toBytes("col2-<d2v1>-<d3v2>"), Bytes.toBytes("col3-<d2v1>-<d3v2>"),
      Bytes.toBytes("col4-<d2v1>-<d3v2>"), Bytes.toBytes("col5-<d2v1>-<d3v2>"),
      Bytes.toBytes("col6-<d2v1>-<d3v2>"), Bytes.toBytes("col7-<d2v1>-<d3v2>"),
      Bytes.toBytes("col8-<d2v1>-<d3v2>"), Bytes.toBytes("col9-<d2v1>-<d3v2>")
  };
  for(int i=0;i<10;i++) {
    Put put = new Put(ROWS[i]);
    put.setDurability(Durability.SKIP_WAL);
    put.add(FAMILY, QUALIFIERS[i], VALUE);
    ht.put(put);
  }
  Scan scan = new Scan();
  scan.addFamily(FAMILY);
  Filter filter = new QualifierFilter(CompareOp.EQUAL,
    new RegexStringComparator("col[1-5]"));
  scan.setFilter(filter);
  ResultScanner scanner = ht.getScanner(scan);
  int expectedIndex = 1;
  for(Result result : ht.getScanner(scan)) {
    assertEquals(result.size(), 1);
    assertTrue(Bytes.equals(CellUtil.cloneRow(result.rawCells()[0]), ROWS[expectedIndex]));
    assertTrue(Bytes.equals(CellUtil.cloneQualifier(result.rawCells()[0]),
        QUALIFIERS[expectedIndex]));
    expectedIndex++;
  }
  assertEquals(expectedIndex, 6);
  scanner.close();
}

项目：ditb 文件：TestFromClientSide.java

@Test
public void testFiltersWithReverseScan() throws Exception {
  TableName TABLE = TableName.valueOf("testFiltersWithReverseScan");
  Table ht = TEST_UTIL.createTable(TABLE, FAMILY);
  byte[][] ROWS = makeN(ROW, 10);
  byte[][] QUALIFIERS = { Bytes.toBytes("col0-<d2v1>-<d3v2>"),
      Bytes.toBytes("col1-<d2v1>-<d3v2>"),
      Bytes.toBytes("col2-<d2v1>-<d3v2>"),
      Bytes.toBytes("col3-<d2v1>-<d3v2>"),
      Bytes.toBytes("col4-<d2v1>-<d3v2>"),
      Bytes.toBytes("col5-<d2v1>-<d3v2>"),
      Bytes.toBytes("col6-<d2v1>-<d3v2>"),
      Bytes.toBytes("col7-<d2v1>-<d3v2>"),
      Bytes.toBytes("col8-<d2v1>-<d3v2>"),
      Bytes.toBytes("col9-<d2v1>-<d3v2>") };
  for (int i = 0; i < 10; i++) {
    Put put = new Put(ROWS[i]);
    put.add(FAMILY, QUALIFIERS[i], VALUE);
    ht.put(put);
  }
  Scan scan = new Scan();
  scan.setReversed(true);
  scan.addFamily(FAMILY);
  Filter filter = new QualifierFilter(CompareOp.EQUAL,
      new RegexStringComparator("col[1-5]"));
  scan.setFilter(filter);
  ResultScanner scanner = ht.getScanner(scan);
  int expectedIndex = 5;
  for (Result result : scanner) {
    assertEquals(result.size(), 1);
    assertTrue(Bytes.equals(result.raw()[0].getRow(), ROWS[expectedIndex]));
    assertTrue(Bytes.equals(result.raw()[0].getQualifier(),
        QUALIFIERS[expectedIndex]));
    expectedIndex--;
  }
  assertEquals(expectedIndex, 0);
  scanner.close();
  ht.close();
}

项目：ditb 文件：TestScannersWithFilters.java

@Test
public void testSkipFilter() throws Exception {
  // Test for qualifier regex: "testQualifierOne-2"
  // Should only get rows from second group, and all keys
  Filter f = new SkipFilter(new QualifierFilter(CompareOp.NOT_EQUAL,
      new BinaryComparator(Bytes.toBytes("testQualifierOne-2"))));
  Scan s = new Scan();
  s.setFilter(f);

  KeyValue [] kvs = {
      // testRowTwo-0
      new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]),
      // testRowTwo-2
      new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]),
      // testRowTwo-3
      new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]),
  };
  verifyScanFull(s, kvs);
}

项目：LCIndex-HBase-0.94.16 文件：TestFromClientSide.java

@Test
public void testFilters() throws Exception {
  byte [] TABLE = Bytes.toBytes("testFilters");
  HTable ht = TEST_UTIL.createTable(TABLE, FAMILY);
  byte [][] ROWS = makeN(ROW, 10);
  byte [][] QUALIFIERS = {
      Bytes.toBytes("col0-<d2v1>-<d3v2>"), Bytes.toBytes("col1-<d2v1>-<d3v2>"),
      Bytes.toBytes("col2-<d2v1>-<d3v2>"), Bytes.toBytes("col3-<d2v1>-<d3v2>"),
      Bytes.toBytes("col4-<d2v1>-<d3v2>"), Bytes.toBytes("col5-<d2v1>-<d3v2>"),
      Bytes.toBytes("col6-<d2v1>-<d3v2>"), Bytes.toBytes("col7-<d2v1>-<d3v2>"),
      Bytes.toBytes("col8-<d2v1>-<d3v2>"), Bytes.toBytes("col9-<d2v1>-<d3v2>")
  };
  for(int i=0;i<10;i++) {
    Put put = new Put(ROWS[i]);
    put.setWriteToWAL(false);
    put.add(FAMILY, QUALIFIERS[i], VALUE);
    ht.put(put);
  }
  Scan scan = new Scan();
  scan.addFamily(FAMILY);
  Filter filter = new QualifierFilter(CompareOp.EQUAL,
    new RegexStringComparator("col[1-5]"));
  scan.setFilter(filter);
  ResultScanner scanner = ht.getScanner(scan);
  int expectedIndex = 1;
  for(Result result : ht.getScanner(scan)) {
    assertEquals(result.size(), 1);
    assertTrue(Bytes.equals(result.raw()[0].getRow(), ROWS[expectedIndex]));
    assertTrue(Bytes.equals(result.raw()[0].getQualifier(),
        QUALIFIERS[expectedIndex]));
    expectedIndex++;
  }
  assertEquals(expectedIndex, 6);
  scanner.close();
}

项目：LCIndex-HBase-0.94.16 文件：TestScannersWithFilters.java

@Test
public void testSkipFilter() throws Exception {
  // Test for qualifier regex: "testQualifierOne-2"
  // Should only get rows from second group, and all keys
  Filter f = new SkipFilter(new QualifierFilter(CompareOp.NOT_EQUAL,
      new BinaryComparator(Bytes.toBytes("testQualifierOne-2"))));
  Scan s = new Scan();
  s.setFilter(f);

  KeyValue [] kvs = {
      // testRowTwo-0
      new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]),
      // testRowTwo-2
      new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]),
      // testRowTwo-3
      new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]),
  };
  verifyScanFull(s, kvs);
}

项目：cloud-bigtable-client 文件：QualifierFilterAdapter.java

@Override
public RowFilter adapt(FilterAdapterContext context, QualifierFilter filter)
    throws IOException {
  if (filter.getComparator() instanceof RegexStringComparator) {
    return adaptRegexStringComparator(
        filter.getOperator(), (RegexStringComparator) filter.getComparator());
  } else if (filter.getComparator() instanceof BinaryComparator) {
    return adaptBinaryComparator(
        context, filter.getOperator(), (BinaryComparator) filter.getComparator());
  }
  throw new IllegalStateException(
      String.format(
          "Cannot adapt comparator %s",
          filter.getComparator().getClass().getCanonicalName()));
}

项目：cloud-bigtable-client 文件：TestQualifierFilterAdapter.java

private void assertAdaptedForm(
    ByteArrayComparable comparable, CompareFilter.CompareOp op, RowFilter expectedFilter)
    throws IOException {
  QualifierFilter filter = new QualifierFilter(op, comparable);
  RowFilter actualFilter = adapter.adapt(scanWithOnFamilyScanContext, filter);
  Assert.assertEquals(expectedFilter, actualFilter);
}

项目：pbase 文件：TestFromClientSide.java

@Test
public void testFilters() throws Exception {
  byte [] TABLE = Bytes.toBytes("testFilters");
  Table ht = TEST_UTIL.createTable(TABLE, FAMILY);
  byte [][] ROWS = makeN(ROW, 10);
  byte [][] QUALIFIERS = {
      Bytes.toBytes("col0-<d2v1>-<d3v2>"), Bytes.toBytes("col1-<d2v1>-<d3v2>"),
      Bytes.toBytes("col2-<d2v1>-<d3v2>"), Bytes.toBytes("col3-<d2v1>-<d3v2>"),
      Bytes.toBytes("col4-<d2v1>-<d3v2>"), Bytes.toBytes("col5-<d2v1>-<d3v2>"),
      Bytes.toBytes("col6-<d2v1>-<d3v2>"), Bytes.toBytes("col7-<d2v1>-<d3v2>"),
      Bytes.toBytes("col8-<d2v1>-<d3v2>"), Bytes.toBytes("col9-<d2v1>-<d3v2>")
  };
  for(int i=0;i<10;i++) {
    Put put = new Put(ROWS[i]);
    put.setDurability(Durability.SKIP_WAL);
    put.add(FAMILY, QUALIFIERS[i], VALUE);
    ht.put(put);
  }
  Scan scan = new Scan();
  scan.addFamily(FAMILY);
  Filter filter = new QualifierFilter(CompareOp.EQUAL,
    new RegexStringComparator("col[1-5]"));
  scan.setFilter(filter);
  ResultScanner scanner = ht.getScanner(scan);
  int expectedIndex = 1;
  for(Result result : ht.getScanner(scan)) {
    assertEquals(result.size(), 1);
    assertTrue(Bytes.equals(CellUtil.cloneRow(result.rawCells()[0]), ROWS[expectedIndex]));
    assertTrue(Bytes.equals(CellUtil.cloneQualifier(result.rawCells()[0]),
        QUALIFIERS[expectedIndex]));
    expectedIndex++;
  }
  assertEquals(expectedIndex, 6);
  scanner.close();
}

项目：pbase 文件：TestFromClientSide.java

@Test
public void testFiltersWithReverseScan() throws Exception {
  TableName TABLE = TableName.valueOf("testFiltersWithReverseScan");
  Table ht = TEST_UTIL.createTable(TABLE, FAMILY);
  byte[][] ROWS = makeN(ROW, 10);
  byte[][] QUALIFIERS = { Bytes.toBytes("col0-<d2v1>-<d3v2>"),
      Bytes.toBytes("col1-<d2v1>-<d3v2>"),
      Bytes.toBytes("col2-<d2v1>-<d3v2>"),
      Bytes.toBytes("col3-<d2v1>-<d3v2>"),
      Bytes.toBytes("col4-<d2v1>-<d3v2>"),
      Bytes.toBytes("col5-<d2v1>-<d3v2>"),
      Bytes.toBytes("col6-<d2v1>-<d3v2>"),
      Bytes.toBytes("col7-<d2v1>-<d3v2>"),
      Bytes.toBytes("col8-<d2v1>-<d3v2>"),
      Bytes.toBytes("col9-<d2v1>-<d3v2>") };
  for (int i = 0; i < 10; i++) {
    Put put = new Put(ROWS[i]);
    put.add(FAMILY, QUALIFIERS[i], VALUE);
    ht.put(put);
  }
  Scan scan = new Scan();
  scan.setReversed(true);
  scan.addFamily(FAMILY);
  Filter filter = new QualifierFilter(CompareOp.EQUAL,
      new RegexStringComparator("col[1-5]"));
  scan.setFilter(filter);
  ResultScanner scanner = ht.getScanner(scan);
  int expectedIndex = 5;
  for (Result result : scanner) {
    assertEquals(result.size(), 1);
    assertTrue(Bytes.equals(result.raw()[0].getRow(), ROWS[expectedIndex]));
    assertTrue(Bytes.equals(result.raw()[0].getQualifier(),
        QUALIFIERS[expectedIndex]));
    expectedIndex--;
  }
  assertEquals(expectedIndex, 0);
  scanner.close();
  ht.close();
}

项目：HIndex 文件：TestFromClientSide.java

@Test
public void testFilters() throws Exception {
  byte [] TABLE = Bytes.toBytes("testFilters");
  HTable ht = TEST_UTIL.createTable(TABLE, FAMILY);
  byte [][] ROWS = makeN(ROW, 10);
  byte [][] QUALIFIERS = {
      Bytes.toBytes("col0-<d2v1>-<d3v2>"), Bytes.toBytes("col1-<d2v1>-<d3v2>"),
      Bytes.toBytes("col2-<d2v1>-<d3v2>"), Bytes.toBytes("col3-<d2v1>-<d3v2>"),
      Bytes.toBytes("col4-<d2v1>-<d3v2>"), Bytes.toBytes("col5-<d2v1>-<d3v2>"),
      Bytes.toBytes("col6-<d2v1>-<d3v2>"), Bytes.toBytes("col7-<d2v1>-<d3v2>"),
      Bytes.toBytes("col8-<d2v1>-<d3v2>"), Bytes.toBytes("col9-<d2v1>-<d3v2>")
  };
  for(int i=0;i<10;i++) {
    Put put = new Put(ROWS[i]);
    put.setDurability(Durability.SKIP_WAL);
    put.add(FAMILY, QUALIFIERS[i], VALUE);
    ht.put(put);
  }
  Scan scan = new Scan();
  scan.addFamily(FAMILY);
  Filter filter = new QualifierFilter(CompareOp.EQUAL,
    new RegexStringComparator("col[1-5]"));
  scan.setFilter(filter);
  ResultScanner scanner = ht.getScanner(scan);
  int expectedIndex = 1;
  for(Result result : ht.getScanner(scan)) {
    assertEquals(result.size(), 1);
    assertTrue(Bytes.equals(CellUtil.cloneRow(result.rawCells()[0]), ROWS[expectedIndex]));
    assertTrue(Bytes.equals(CellUtil.cloneQualifier(result.rawCells()[0]),
        QUALIFIERS[expectedIndex]));
    expectedIndex++;
  }
  assertEquals(expectedIndex, 6);
  scanner.close();
}

项目：HIndex 文件：TestFromClientSide.java

@Test
public void testFiltersWithReverseScan() throws Exception {
  byte[] TABLE = Bytes.toBytes("testFiltersWithReverseScan");
  HTable ht = TEST_UTIL.createTable(TABLE, FAMILY);
  byte[][] ROWS = makeN(ROW, 10);
  byte[][] QUALIFIERS = { Bytes.toBytes("col0-<d2v1>-<d3v2>"),
      Bytes.toBytes("col1-<d2v1>-<d3v2>"),
      Bytes.toBytes("col2-<d2v1>-<d3v2>"),
      Bytes.toBytes("col3-<d2v1>-<d3v2>"),
      Bytes.toBytes("col4-<d2v1>-<d3v2>"),
      Bytes.toBytes("col5-<d2v1>-<d3v2>"),
      Bytes.toBytes("col6-<d2v1>-<d3v2>"),
      Bytes.toBytes("col7-<d2v1>-<d3v2>"),
      Bytes.toBytes("col8-<d2v1>-<d3v2>"),
      Bytes.toBytes("col9-<d2v1>-<d3v2>") };
  for (int i = 0; i < 10; i++) {
    Put put = new Put(ROWS[i]);
    put.add(FAMILY, QUALIFIERS[i], VALUE);
    ht.put(put);
  }
  Scan scan = new Scan();
  scan.setReversed(true);
  scan.addFamily(FAMILY);
  Filter filter = new QualifierFilter(CompareOp.EQUAL,
      new RegexStringComparator("col[1-5]"));
  scan.setFilter(filter);
  ResultScanner scanner = ht.getScanner(scan);
  int expectedIndex = 5;
  for (Result result : scanner) {
    assertEquals(result.size(), 1);
    assertTrue(Bytes.equals(result.raw()[0].getRow(), ROWS[expectedIndex]));
    assertTrue(Bytes.equals(result.raw()[0].getQualifier(),
        QUALIFIERS[expectedIndex]));
    expectedIndex--;
  }
  assertEquals(expectedIndex, 0);
  scanner.close();
  ht.close();
}

项目：HIndex 文件：TestScannersWithFilters.java

@Test
public void testSkipFilter() throws Exception {
  // Test for qualifier regex: "testQualifierOne-2"
  // Should only get rows from second group, and all keys
  Filter f = new SkipFilter(new QualifierFilter(CompareOp.NOT_EQUAL,
      new BinaryComparator(Bytes.toBytes("testQualifierOne-2"))));
  Scan s = new Scan();
  s.setFilter(f);

  KeyValue [] kvs = {
      // testRowTwo-0
      new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]),
      // testRowTwo-2
      new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]),
      // testRowTwo-3
      new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]),
  };
  verifyScanFull(s, kvs);
}

项目：playorm 文件：CursorColumnSliceHbase.java

private QualifierFilter createFilterFrom() {
    if (BigInteger.class.equals(columnNameType)) {
        int flippedFrom = StandardConverters.convertFromBytes(Integer.class, from);
        flippedFrom ^= (1 << 31);
        from = Bytes.toBytes(flippedFrom);
    }
    BinaryComparator startColumn = new BinaryComparator(from);
    CompareFilter.CompareOp  fromInclusive = CompareOp.GREATER_OR_EQUAL;
    return new QualifierFilter(fromInclusive, startColumn);
}

项目：playorm 文件：CursorColumnSliceHbase.java

private QualifierFilter createFilterTo() {
    if (BigInteger.class.equals(columnNameType)) {
        int flippedTo = StandardConverters.convertFromBytes(Integer.class, to);
        flippedTo ^= (1 << 31);
        to = Bytes.toBytes(flippedTo);
    }
    BinaryComparator endColumn = new BinaryComparator(to);
    CompareFilter.CompareOp toInclusive = CompareOp.LESS_OR_EQUAL;
    return new QualifierFilter(toInclusive, endColumn);
}

项目：hbase-in-action 文件：QualifierFilterApp.java

public static void main(String[] args) throws IOException {
    Configuration configuration = getConfiguration();
    HBaseHelper helper = HBaseHelper.getHelper(configuration);
    Connection connection = helper.getConnection();

    /*helper.dropTable(TEST_TABLE_NAME);
    helper.createTable(TEST_TABLE_NAME, "colfam1", "colfam2");
    log.info("Adding rows to table...");
    helper.fillTable("testtable", 1, 10, 10, "colfam1", "colfam2");*/

    Table table = connection.getTable(TableName.valueOf(TEST_TABLE_NAME));

    Filter filter = new QualifierFilter(CompareOp.LESS_OR_EQUAL, new BinaryComparator(Bytes.toBytes("col-2")));

    Scan scan = new Scan();
    scan.setFilter(filter);

    ResultScanner scanner = table.getScanner(scan);
    log.info("Scanning table... ");
    for (Result result : scanner) {
      log.info(result.toString());
    }
    scanner.close();

    Get get1 = new Get(Bytes.toBytes("row-5"));
    get1.setFilter(filter);
    Result result1 = table.get(get1);
    log.info("Result of get(): {}", result1);

}

项目：IRIndex 文件：TestFromClientSide.java

@Test
public void testFilters() throws Exception {
  byte [] TABLE = Bytes.toBytes("testFilters");
  HTable ht = TEST_UTIL.createTable(TABLE, FAMILY);
  byte [][] ROWS = makeN(ROW, 10);
  byte [][] QUALIFIERS = {
      Bytes.toBytes("col0-<d2v1>-<d3v2>"), Bytes.toBytes("col1-<d2v1>-<d3v2>"),
      Bytes.toBytes("col2-<d2v1>-<d3v2>"), Bytes.toBytes("col3-<d2v1>-<d3v2>"),
      Bytes.toBytes("col4-<d2v1>-<d3v2>"), Bytes.toBytes("col5-<d2v1>-<d3v2>"),
      Bytes.toBytes("col6-<d2v1>-<d3v2>"), Bytes.toBytes("col7-<d2v1>-<d3v2>"),
      Bytes.toBytes("col8-<d2v1>-<d3v2>"), Bytes.toBytes("col9-<d2v1>-<d3v2>")
  };
  for(int i=0;i<10;i++) {
    Put put = new Put(ROWS[i]);
    put.setWriteToWAL(false);
    put.add(FAMILY, QUALIFIERS[i], VALUE);
    ht.put(put);
  }
  Scan scan = new Scan();
  scan.addFamily(FAMILY);
  Filter filter = new QualifierFilter(CompareOp.EQUAL,
    new RegexStringComparator("col[1-5]"));
  scan.setFilter(filter);
  ResultScanner scanner = ht.getScanner(scan);
  int expectedIndex = 1;
  for(Result result : ht.getScanner(scan)) {
    assertEquals(result.size(), 1);
    assertTrue(Bytes.equals(result.raw()[0].getRow(), ROWS[expectedIndex]));
    assertTrue(Bytes.equals(result.raw()[0].getQualifier(),
        QUALIFIERS[expectedIndex]));
    expectedIndex++;
  }
  assertEquals(expectedIndex, 6);
  scanner.close();
}

项目：IRIndex 文件：TestScannersWithFilters.java

@Test
public void testSkipFilter() throws Exception {
  // Test for qualifier regex: "testQualifierOne-2"
  // Should only get rows from second group, and all keys
  Filter f = new SkipFilter(new QualifierFilter(CompareOp.NOT_EQUAL,
      new BinaryComparator(Bytes.toBytes("testQualifierOne-2"))));
  Scan s = new Scan();
  s.setFilter(f);

  KeyValue [] kvs = {
      // testRowTwo-0
      new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]),
      // testRowTwo-2
      new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]),
      // testRowTwo-3
      new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]),
  };
  verifyScanFull(s, kvs);
}

项目：IRIndex 文件：TestScannersWithFilters.java

@Test
public void testFilterList() throws Exception {
  // Test getting a single row, single key using Row, Qualifier, and Value 
  // regular expression and substring filters
  // Use must pass all
  List<Filter> filters = new ArrayList<Filter>();
  filters.add(new RowFilter(CompareOp.EQUAL,
    new RegexStringComparator(".+-2")));
  filters.add(new QualifierFilter(CompareOp.EQUAL,
    new RegexStringComparator(".+-2")));
  filters.add(new ValueFilter(CompareOp.EQUAL,
    new SubstringComparator("One")));
  Filter f = new FilterList(Operator.MUST_PASS_ALL, filters);
  Scan s = new Scan();
  s.addFamily(FAMILIES[0]);
  s.setFilter(f);
  KeyValue [] kvs = {
      new KeyValue(ROWS_ONE[2], FAMILIES[0], QUALIFIERS_ONE[2], VALUES[0])
  };
  verifyScanFull(s, kvs);

  // Test getting everything with a MUST_PASS_ONE filter including row, qf,
  // val, regular expression and substring filters
  filters.clear();
  filters.add(new RowFilter(CompareOp.EQUAL,
    new RegexStringComparator(".+Two.+")));
  filters.add(new QualifierFilter(CompareOp.EQUAL,
    new RegexStringComparator(".+-2")));
  filters.add(new ValueFilter(CompareOp.EQUAL,
    new SubstringComparator("One")));
  f = new FilterList(Operator.MUST_PASS_ONE, filters);
  s = new Scan();
  s.setFilter(f);
  verifyScanNoEarlyOut(s, numRows, colsPerRow);
}

项目：hbase 文件：AccessControlLists.java

static private void removeTablePermissions(TableName tableName, byte[] column, Table table,
    boolean closeTable) throws IOException {
  Scan scan = new Scan();
  scan.addFamily(ACL_LIST_FAMILY);

  String columnName = Bytes.toString(column);
  scan.setFilter(new QualifierFilter(CompareOperator.EQUAL, new RegexStringComparator(
      String.format("(%s%s%s)|(%s%s)$",
          ACL_KEY_DELIMITER, columnName, ACL_KEY_DELIMITER,
          ACL_KEY_DELIMITER, columnName))));

  Set<byte[]> qualifierSet = new TreeSet<>(Bytes.BYTES_COMPARATOR);
  ResultScanner scanner = null;
  try {
    scanner = table.getScanner(scan);
    for (Result res : scanner) {
      for (byte[] q : res.getFamilyMap(ACL_LIST_FAMILY).navigableKeySet()) {
        qualifierSet.add(q);
      }
    }

    if (qualifierSet.size() > 0) {
      Delete d = new Delete(tableName.getName());
      for (byte[] qualifier : qualifierSet) {
        d.addColumns(ACL_LIST_FAMILY, qualifier);
      }
      table.delete(d);
    }
  } finally {
    if (scanner != null) scanner.close();
    if (closeTable) table.close();
  }
}

项目：hbase 文件：TestFromClientSide.java

@Test
public void testFilters() throws Exception {
  final TableName tableName = TableName.valueOf(name.getMethodName());
  Table ht = TEST_UTIL.createTable(tableName, FAMILY);
  byte [][] ROWS = makeN(ROW, 10);
  byte [][] QUALIFIERS = {
      Bytes.toBytes("col0-<d2v1>-<d3v2>"), Bytes.toBytes("col1-<d2v1>-<d3v2>"),
      Bytes.toBytes("col2-<d2v1>-<d3v2>"), Bytes.toBytes("col3-<d2v1>-<d3v2>"),
      Bytes.toBytes("col4-<d2v1>-<d3v2>"), Bytes.toBytes("col5-<d2v1>-<d3v2>"),
      Bytes.toBytes("col6-<d2v1>-<d3v2>"), Bytes.toBytes("col7-<d2v1>-<d3v2>"),
      Bytes.toBytes("col8-<d2v1>-<d3v2>"), Bytes.toBytes("col9-<d2v1>-<d3v2>")
  };
  for(int i=0;i<10;i++) {
    Put put = new Put(ROWS[i]);
    put.setDurability(Durability.SKIP_WAL);
    put.addColumn(FAMILY, QUALIFIERS[i], VALUE);
    ht.put(put);
  }
  Scan scan = new Scan();
  scan.addFamily(FAMILY);
  Filter filter = new QualifierFilter(CompareOperator.EQUAL,
    new RegexStringComparator("col[1-5]"));
  scan.setFilter(filter);
  ResultScanner scanner = ht.getScanner(scan);
  int expectedIndex = 1;
  for(Result result : ht.getScanner(scan)) {
    assertEquals(1, result.size());
    assertTrue(Bytes.equals(CellUtil.cloneRow(result.rawCells()[0]), ROWS[expectedIndex]));
    assertTrue(Bytes.equals(CellUtil.cloneQualifier(result.rawCells()[0]),
        QUALIFIERS[expectedIndex]));
    expectedIndex++;
  }
  assertEquals(6, expectedIndex);
  scanner.close();
}

项目：hbase 文件：TestScannersWithFilters.java

@Test
public void testSkipFilter() throws Exception {
  // Test for qualifier regex: "testQualifierOne-2"
  // Should only get rows from second group, and all keys
  Filter f = new SkipFilter(new QualifierFilter(CompareOperator.NOT_EQUAL,
      new BinaryComparator(Bytes.toBytes("testQualifierOne-2"))));
  Scan s = new Scan();
  s.setFilter(f);

  KeyValue [] kvs = {
      // testRowTwo-0
      new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]),
      // testRowTwo-2
      new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]),
      // testRowTwo-3
      new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]),
  };
  verifyScanFull(s, kvs);
}

项目：hbase 文件：TestScannersWithFilters.java

@Test
public void testFilterList() throws Exception {
  // Test getting a single row, single key using Row, Qualifier, and Value
  // regular expression and substring filters
  // Use must pass all
  List<Filter> filters = new ArrayList<>(3);
  filters.add(new RowFilter(CompareOperator.EQUAL,
    new RegexStringComparator(".+-2")));
  filters.add(new QualifierFilter(CompareOperator.EQUAL,
    new RegexStringComparator(".+-2")));
  filters.add(new ValueFilter(CompareOperator.EQUAL,
    new SubstringComparator("One")));
  Filter f = new FilterList(Operator.MUST_PASS_ALL, filters);
  Scan s = new Scan();
  s.addFamily(FAMILIES[0]);
  s.setFilter(f);
  KeyValue [] kvs = {
      new KeyValue(ROWS_ONE[2], FAMILIES[0], QUALIFIERS_ONE[2], VALUES[0])
  };
  verifyScanFull(s, kvs);

  // Test getting everything with a MUST_PASS_ONE filter including row, qf,
  // val, regular expression and substring filters
  filters.clear();
  filters.add(new RowFilter(CompareOperator.EQUAL,
    new RegexStringComparator(".+Two.+")));
  filters.add(new QualifierFilter(CompareOperator.EQUAL,
    new RegexStringComparator(".+-2")));
  filters.add(new ValueFilter(CompareOperator.EQUAL,
    new SubstringComparator("One")));
  f = new FilterList(Operator.MUST_PASS_ONE, filters);
  s = new Scan();
  s.setFilter(f);
  verifyScanNoEarlyOut(s, numRows, colsPerRow);
}

项目：PyroDB 文件：TestFromClientSide.java

@Test
public void testFilters() throws Exception {
  byte [] TABLE = Bytes.toBytes("testFilters");
  HTable ht = TEST_UTIL.createTable(TABLE, FAMILY);
  byte [][] ROWS = makeN(ROW, 10);
  byte [][] QUALIFIERS = {
      Bytes.toBytes("col0-<d2v1>-<d3v2>"), Bytes.toBytes("col1-<d2v1>-<d3v2>"),
      Bytes.toBytes("col2-<d2v1>-<d3v2>"), Bytes.toBytes("col3-<d2v1>-<d3v2>"),
      Bytes.toBytes("col4-<d2v1>-<d3v2>"), Bytes.toBytes("col5-<d2v1>-<d3v2>"),
      Bytes.toBytes("col6-<d2v1>-<d3v2>"), Bytes.toBytes("col7-<d2v1>-<d3v2>"),
      Bytes.toBytes("col8-<d2v1>-<d3v2>"), Bytes.toBytes("col9-<d2v1>-<d3v2>")
  };
  for(int i=0;i<10;i++) {
    Put put = new Put(ROWS[i]);
    put.setDurability(Durability.SKIP_WAL);
    put.add(FAMILY, QUALIFIERS[i], VALUE);
    ht.put(put);
  }
  Scan scan = new Scan();
  scan.addFamily(FAMILY);
  Filter filter = new QualifierFilter(CompareOp.EQUAL,
    new RegexStringComparator("col[1-5]"));
  scan.setFilter(filter);
  ResultScanner scanner = ht.getScanner(scan);
  int expectedIndex = 1;
  for(Result result : ht.getScanner(scan)) {
    assertEquals(result.size(), 1);
    assertTrue(Bytes.equals(CellUtil.cloneRow(result.rawCells()[0]), ROWS[expectedIndex]));
    assertTrue(Bytes.equals(CellUtil.cloneQualifier(result.rawCells()[0]),
        QUALIFIERS[expectedIndex]));
    expectedIndex++;
  }
  assertEquals(expectedIndex, 6);
  scanner.close();
}

项目：PyroDB 文件：TestFromClientSide.java

@Test
public void testFiltersWithReverseScan() throws Exception {
  byte[] TABLE = Bytes.toBytes("testFiltersWithReverseScan");
  HTable ht = TEST_UTIL.createTable(TABLE, FAMILY);
  byte[][] ROWS = makeN(ROW, 10);
  byte[][] QUALIFIERS = { Bytes.toBytes("col0-<d2v1>-<d3v2>"),
      Bytes.toBytes("col1-<d2v1>-<d3v2>"),
      Bytes.toBytes("col2-<d2v1>-<d3v2>"),
      Bytes.toBytes("col3-<d2v1>-<d3v2>"),
      Bytes.toBytes("col4-<d2v1>-<d3v2>"),
      Bytes.toBytes("col5-<d2v1>-<d3v2>"),
      Bytes.toBytes("col6-<d2v1>-<d3v2>"),
      Bytes.toBytes("col7-<d2v1>-<d3v2>"),
      Bytes.toBytes("col8-<d2v1>-<d3v2>"),
      Bytes.toBytes("col9-<d2v1>-<d3v2>") };
  for (int i = 0; i < 10; i++) {
    Put put = new Put(ROWS[i]);
    put.add(FAMILY, QUALIFIERS[i], VALUE);
    ht.put(put);
  }
  Scan scan = new Scan();
  scan.setReversed(true);
  scan.addFamily(FAMILY);
  Filter filter = new QualifierFilter(CompareOp.EQUAL,
      new RegexStringComparator("col[1-5]"));
  scan.setFilter(filter);
  ResultScanner scanner = ht.getScanner(scan);
  int expectedIndex = 5;
  for (Result result : scanner) {
    assertEquals(result.size(), 1);
    assertTrue(Bytes.equals(result.raw()[0].getRow(), ROWS[expectedIndex]));
    assertTrue(Bytes.equals(result.raw()[0].getQualifier(),
        QUALIFIERS[expectedIndex]));
    expectedIndex--;
  }
  assertEquals(expectedIndex, 0);
  scanner.close();
  ht.close();
}

项目：PyroDB 文件：TestScannersWithFilters.java

@Test
public void testSkipFilter() throws Exception {
  // Test for qualifier regex: "testQualifierOne-2"
  // Should only get rows from second group, and all keys
  Filter f = new SkipFilter(new QualifierFilter(CompareOp.NOT_EQUAL,
      new BinaryComparator(Bytes.toBytes("testQualifierOne-2"))));
  Scan s = new Scan();
  s.setFilter(f);

  KeyValue [] kvs = {
      // testRowTwo-0
      new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]),
      // testRowTwo-2
      new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]),
      // testRowTwo-3
      new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]),
  };
  verifyScanFull(s, kvs);
}

项目：PyroDB 文件：TestScannersWithFilters.java

@Test
public void testFilterList() throws Exception {
  // Test getting a single row, single key using Row, Qualifier, and Value 
  // regular expression and substring filters
  // Use must pass all
  List<Filter> filters = new ArrayList<Filter>();
  filters.add(new RowFilter(CompareOp.EQUAL,
    new RegexStringComparator(".+-2")));
  filters.add(new QualifierFilter(CompareOp.EQUAL,
    new RegexStringComparator(".+-2")));
  filters.add(new ValueFilter(CompareOp.EQUAL,
    new SubstringComparator("One")));
  Filter f = new FilterList(Operator.MUST_PASS_ALL, filters);
  Scan s = new Scan();
  s.addFamily(FAMILIES[0]);
  s.setFilter(f);
  KeyValue [] kvs = {
      new KeyValue(ROWS_ONE[2], FAMILIES[0], QUALIFIERS_ONE[2], VALUES[0])
  };
  verifyScanFull(s, kvs);

  // Test getting everything with a MUST_PASS_ONE filter including row, qf,
  // val, regular expression and substring filters
  filters.clear();
  filters.add(new RowFilter(CompareOp.EQUAL,
    new RegexStringComparator(".+Two.+")));
  filters.add(new QualifierFilter(CompareOp.EQUAL,
    new RegexStringComparator(".+-2")));
  filters.add(new ValueFilter(CompareOp.EQUAL,
    new SubstringComparator("One")));
  f = new FilterList(Operator.MUST_PASS_ONE, filters);
  s = new Scan();
  s.setFilter(f);
  verifyScanNoEarlyOut(s, numRows, colsPerRow);
}

项目：spork-streaming 文件：TestHBaseStorageFiltering.java

private void assertQualifierFilter(Filter filter, CompareFilter.CompareOp compareOp, String value) {
    assertTrue("Filter is not a QualifierFilter: " + filter.getClass().getSimpleName(),
            filter instanceof QualifierFilter);
    QualifierFilter qualifierFilter = (QualifierFilter)filter;
    assertEquals("Unexpected compareOp", compareOp, qualifierFilter.getOperator());
    assertEquals("Unexpected value", value, Bytes.toString(qualifierFilter.getComparator().getValue()));
}

项目：c5 文件：TestFromClientSide.java

@Test
public void testFilters() throws Exception {
  byte [] TABLE = Bytes.toBytes("testFilters");
  HTable ht = TEST_UTIL.createTable(TABLE, FAMILY);
  byte [][] ROWS = makeN(ROW, 10);
  byte [][] QUALIFIERS = {
      Bytes.toBytes("col0-<d2v1>-<d3v2>"), Bytes.toBytes("col1-<d2v1>-<d3v2>"),
      Bytes.toBytes("col2-<d2v1>-<d3v2>"), Bytes.toBytes("col3-<d2v1>-<d3v2>"),
      Bytes.toBytes("col4-<d2v1>-<d3v2>"), Bytes.toBytes("col5-<d2v1>-<d3v2>"),
      Bytes.toBytes("col6-<d2v1>-<d3v2>"), Bytes.toBytes("col7-<d2v1>-<d3v2>"),
      Bytes.toBytes("col8-<d2v1>-<d3v2>"), Bytes.toBytes("col9-<d2v1>-<d3v2>")
  };
  for(int i=0;i<10;i++) {
    Put put = new Put(ROWS[i]);
    put.setDurability(Durability.SKIP_WAL);
    put.add(FAMILY, QUALIFIERS[i], VALUE);
    ht.put(put);
  }
  Scan scan = new Scan();
  scan.addFamily(FAMILY);
  Filter filter = new QualifierFilter(CompareOp.EQUAL,
    new RegexStringComparator("col[1-5]"));
  scan.setFilter(filter);
  ResultScanner scanner = ht.getScanner(scan);
  int expectedIndex = 1;
  for(Result result : ht.getScanner(scan)) {
    assertEquals(result.size(), 1);
    assertTrue(Bytes.equals(CellUtil.cloneRow(result.rawCells()[0]), ROWS[expectedIndex]));
    assertTrue(Bytes.equals(CellUtil.cloneQualifier(result.rawCells()[0]),
        QUALIFIERS[expectedIndex]));
    expectedIndex++;
  }
  assertEquals(expectedIndex, 6);
  scanner.close();
}

项目：c5 文件：TestScannersWithFilters.java

@Test
public void testSkipFilter() throws Exception {
  // Test for qualifier regex: "testQualifierOne-2"
  // Should only get rows from second group, and all keys
  Filter f = new SkipFilter(new QualifierFilter(CompareOp.NOT_EQUAL,
      new BinaryComparator(Bytes.toBytes("testQualifierOne-2"))));
  Scan s = new Scan();
  s.setFilter(f);

  KeyValue [] kvs = {
      // testRowTwo-0
      new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]),
      // testRowTwo-2
      new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]),
      // testRowTwo-3
      new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]),
  };
  verifyScanFull(s, kvs);
}

项目：c5 文件：TestScannersWithFilters.java

@Test
public void testFilterList() throws Exception {
  // Test getting a single row, single key using Row, Qualifier, and Value 
  // regular expression and substring filters
  // Use must pass all
  List<Filter> filters = new ArrayList<Filter>();
  filters.add(new RowFilter(CompareOp.EQUAL,
    new RegexStringComparator(".+-2")));
  filters.add(new QualifierFilter(CompareOp.EQUAL,
    new RegexStringComparator(".+-2")));
  filters.add(new ValueFilter(CompareOp.EQUAL,
    new SubstringComparator("One")));
  Filter f = new FilterList(Operator.MUST_PASS_ALL, filters);
  Scan s = new Scan();
  s.addFamily(FAMILIES[0]);
  s.setFilter(f);
  KeyValue [] kvs = {
      new KeyValue(ROWS_ONE[2], FAMILIES[0], QUALIFIERS_ONE[2], VALUES[0])
  };
  verifyScanFull(s, kvs);

  // Test getting everything with a MUST_PASS_ONE filter including row, qf,
  // val, regular expression and substring filters
  filters.clear();
  filters.add(new RowFilter(CompareOp.EQUAL,
    new RegexStringComparator(".+Two.+")));
  filters.add(new QualifierFilter(CompareOp.EQUAL,
    new RegexStringComparator(".+-2")));
  filters.add(new ValueFilter(CompareOp.EQUAL,
    new SubstringComparator("One")));
  f = new FilterList(Operator.MUST_PASS_ONE, filters);
  s = new Scan();
  s.setFilter(f);
  verifyScanNoEarlyOut(s, numRows, colsPerRow);
}

项目：spork 文件：TestHBaseStorageFiltering.java

private void assertQualifierFilter(Filter filter, CompareFilter.CompareOp compareOp, String value) {
    assertTrue("Filter is not a QualifierFilter: " + filter.getClass().getSimpleName(),
            filter instanceof QualifierFilter);
    QualifierFilter qualifierFilter = (QualifierFilter)filter;
    assertEquals("Unexpected compareOp", compareOp, qualifierFilter.getOperator());
    assertEquals("Unexpected value", value, Bytes.toString(qualifierFilter.getComparator().getValue()));
}

项目：pinpoint 文件：HbaseAgentEventDao.java

@Override
public List<AgentEventBo> getAgentEvents(String agentId, Range range, Set<AgentEventType> excludeEventTypes) {
    if (agentId == null) {
        throw new NullPointerException("agentId must not be null");
    }
    if (range == null) {
        throw new NullPointerException("range must not be null");
    }

    Scan scan = new Scan();
    scan.setMaxVersions(1);
    scan.setCaching(SCANNER_CACHE_SIZE);

    scan.setStartRow(createRowKey(agentId, range.getTo()));
    scan.setStopRow(createRowKey(agentId, range.getFrom()));
    scan.addFamily(HBaseTables.AGENT_EVENT_CF_EVENTS);

    if (!CollectionUtils.isEmpty(excludeEventTypes)) {
        FilterList filterList = new FilterList(FilterList.Operator.MUST_PASS_ALL);
        for (AgentEventType excludeEventType : excludeEventTypes) {
            byte[] excludeQualifier = Bytes.toBytes(excludeEventType.getCode());
            filterList.addFilter(new QualifierFilter(CompareFilter.CompareOp.NOT_EQUAL, new BinaryComparator(excludeQualifier)));
        }
        scan.setFilter(filterList);
    }

    TableName agentEventTableName = tableNameProvider.getTableName(HBaseTables.AGENT_EVENT_STR);
    List<AgentEventBo> agentEvents = this.hbaseOperations2.find(agentEventTableName, scan, agentEventResultsExtractor);
    logger.debug("agentEvents found. {}", agentEvents);
    return agentEvents;
}

项目：pentaho-hadoop-shims 文件：CommonHBaseConnection.java

void addFilterByMapping( FilterList fl, CompareFilter.CompareOp comp, Class<?> comparatorClass, Object comparator,
    Mapping.TupleMapping tupleMapping ) throws NoSuchMethodException, InstantiationException, IllegalAccessException,
    java.lang.reflect.InvocationTargetException {
  switch ( tupleMapping ) {
    case KEY: {
      addFilter( RowFilter.class, fl, comp, comparatorClass, comparator );
      return;
    }
    case FAMILY: {
      addFilter( FamilyFilter.class, fl, comp, comparatorClass, comparator );
      return;
    }
    case COLUMN: {
      //TODO Check if ColumnPrefixFilter works faster and suit more

      addFilter( QualifierFilter.class, fl, comp, comparatorClass, comparator );
      return;
    }
    case VALUE: {
      addFilter( ValueFilter.class, fl, comp, comparatorClass, comparator );
      return;
    }
    case TIMESTAMP: {
      addFilter( TimestampsFilter.class, fl, comp, comparatorClass, comparator );
      //        Constructor<TimestampsFilter> columnFilterConstructor =
      //          TimestampsFilter.class.getConstructor( CompareFilter.CompareOp.class, comparatorClass );
      //        TimestampsFilter scf = columnFilterConstructor.newInstance( comp, comparator );
      //        fl.addFilter( scf );
      return;
    }
  }
}

项目：pentaho-hadoop-shims 文件：HBase11HBaseConnectionTest.java

@Test
public void testAddFilterByMapping() throws Exception {
  testAddFilterByMapping( Mapping.TupleMapping.KEY, RowFilter.class );
  testAddFilterByMapping( Mapping.TupleMapping.FAMILY, FamilyFilter.class );
  testAddFilterByMapping( Mapping.TupleMapping.COLUMN, QualifierFilter.class );
  testAddFilterByMapping( Mapping.TupleMapping.VALUE, ValueFilter.class );
}

项目：HBase-Research 文件：TestFromClientSide.java

@Test
public void testFilters() throws Exception {
  byte [] TABLE = Bytes.toBytes("testFilters");
  HTable ht = TEST_UTIL.createTable(TABLE, FAMILY);
  byte [][] ROWS = makeN(ROW, 10);
  byte [][] QUALIFIERS = {
      Bytes.toBytes("col0-<d2v1>-<d3v2>"), Bytes.toBytes("col1-<d2v1>-<d3v2>"),
      Bytes.toBytes("col2-<d2v1>-<d3v2>"), Bytes.toBytes("col3-<d2v1>-<d3v2>"),
      Bytes.toBytes("col4-<d2v1>-<d3v2>"), Bytes.toBytes("col5-<d2v1>-<d3v2>"),
      Bytes.toBytes("col6-<d2v1>-<d3v2>"), Bytes.toBytes("col7-<d2v1>-<d3v2>"),
      Bytes.toBytes("col8-<d2v1>-<d3v2>"), Bytes.toBytes("col9-<d2v1>-<d3v2>")
  };
  for(int i=0;i<10;i++) {
    Put put = new Put(ROWS[i]);
    put.setWriteToWAL(false);
    put.add(FAMILY, QUALIFIERS[i], VALUE);
    ht.put(put);
  }
  Scan scan = new Scan();
  scan.addFamily(FAMILY);
  Filter filter = new QualifierFilter(CompareOp.EQUAL,
    new RegexStringComparator("col[1-5]"));
  scan.setFilter(filter);
  ResultScanner scanner = ht.getScanner(scan);
  int expectedIndex = 1;
  for(Result result : ht.getScanner(scan)) {
    assertEquals(result.size(), 1);
    assertTrue(Bytes.equals(result.raw()[0].getRow(), ROWS[expectedIndex]));
    assertTrue(Bytes.equals(result.raw()[0].getQualifier(),
        QUALIFIERS[expectedIndex]));
    expectedIndex++;
  }
  assertEquals(expectedIndex, 6);
  scanner.close();
}

项目：HBase-Research 文件：TestScannersWithFilters.java

@Test
public void testSkipFilter() throws Exception {
  // Test for qualifier regex: "testQualifierOne-2"
  // Should only get rows from second group, and all keys
  Filter f = new SkipFilter(new QualifierFilter(CompareOp.NOT_EQUAL,
      new BinaryComparator(Bytes.toBytes("testQualifierOne-2"))));
  Scan s = new Scan();
  s.setFilter(f);

  KeyValue [] kvs = {
      // testRowTwo-0
      new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[0], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]),
      // testRowTwo-2
      new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[2], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]),
      // testRowTwo-3
      new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[0], QUALIFIERS_TWO[3], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[0], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[2], VALUES[1]),
      new KeyValue(ROWS_TWO[3], FAMILIES[1], QUALIFIERS_TWO[3], VALUES[1]),
  };
  verifyScanFull(s, kvs);
}

项目：HBase-Research 文件：TestScannersWithFilters.java

@Test
public void testFilterList() throws Exception {
  // Test getting a single row, single key using Row, Qualifier, and Value 
  // regular expression and substring filters
  // Use must pass all
  List<Filter> filters = new ArrayList<Filter>();
  filters.add(new RowFilter(CompareOp.EQUAL,
    new RegexStringComparator(".+-2")));
  filters.add(new QualifierFilter(CompareOp.EQUAL,
    new RegexStringComparator(".+-2")));
  filters.add(new ValueFilter(CompareOp.EQUAL,
    new SubstringComparator("One")));
  Filter f = new FilterList(Operator.MUST_PASS_ALL, filters);
  Scan s = new Scan();
  s.addFamily(FAMILIES[0]);
  s.setFilter(f);
  KeyValue [] kvs = {
      new KeyValue(ROWS_ONE[2], FAMILIES[0], QUALIFIERS_ONE[2], VALUES[0])
  };
  verifyScanFull(s, kvs);

  // Test getting everything with a MUST_PASS_ONE filter including row, qf,
  // val, regular expression and substring filters
  filters.clear();
  filters.add(new RowFilter(CompareOp.EQUAL,
    new RegexStringComparator(".+Two.+")));
  filters.add(new QualifierFilter(CompareOp.EQUAL,
    new RegexStringComparator(".+-2")));
  filters.add(new ValueFilter(CompareOp.EQUAL,
    new SubstringComparator("One")));
  f = new FilterList(Operator.MUST_PASS_ONE, filters);
  s = new Scan();
  s.setFilter(f);
  verifyScanNoEarlyOut(s, numRows, colsPerRow);
}