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

@Override
public boolean checkAndDelete(byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, byte[] value, Delete delete) throws IOException {
    if (!Arrays.equals(delete.getRow(), row)) {
        throw new UnsupportedOperationException("CheckAndDelete does not support check one row but delete other row");
    }


    ODelete odelete = ElementConvertor.toOtsDelete(delete, this.tablestoreColumnMapping);
    Condition condition = ElementConvertor.toOtsCondition(family, qualifier, compareOp, value, this.tablestoreColumnMapping);
    odelete.setCondition(condition);

    try {
        this.tablestoreAdaptor.delete(tableNameStr, odelete);
    } catch (IOException ex) {
        if (ex.getCause().getCause() instanceof TableStoreException) {
            TableStoreException exception = (TableStoreException)ex.getCause().getCause();
            if (exception.getErrorCode().equals("OTSConditionCheckFail")) {
                return false;
            }
        }
        throw ex;
    }
    return true;
}

@Override
public boolean checkAndPut(byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, byte[] value, Put put) throws IOException {
    if (!Arrays.equals(put.getRow(), row)) {
        throw new UnsupportedOperationException("CheckAndPut does not support check one row but put other row");
    }

    OPut oput = ElementConvertor.toOtsPut(put, this.tablestoreColumnMapping);
    Condition condition = ElementConvertor.toOtsCondition(family, qualifier, compareOp, value, this.tablestoreColumnMapping);
    oput.setCondition(condition);

    try {
        this.tablestoreAdaptor.put(tableNameStr, oput);
    } catch (IOException ex) {
        if (ex.getCause().getCause() instanceof TableStoreException) {
            TableStoreException exception = (TableStoreException)ex.getCause().getCause();
            if (exception.getErrorCode().equals("OTSConditionCheckFail")) {
                return false;
            }
        }
        throw ex;
    }
    return true;
}

@Override
public boolean checkAndMutate(byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, byte[] value, RowMutations mutation) throws IOException {
    if (!Arrays.equals(mutation.getRow(), row)) {
        throw new UnsupportedOperationException("CheckAndMutation does not support check one row but Mutate other row");
    }

    OUpdate oupdate = ElementConvertor.toOtsUpdate(mutation, this.tablestoreColumnMapping);
    Condition condition = ElementConvertor.toOtsCondition(family, qualifier, compareOp, value, this.tablestoreColumnMapping);
    oupdate.setCondition(condition);

    try {
        this.tablestoreAdaptor.update(tableNameStr, oupdate);
    } catch (IOException ex) {
        if (ex.getCause().getCause() instanceof TableStoreException) {
            TableStoreException exception = (TableStoreException)ex.getCause().getCause();
            if (exception.getErrorCode().equals("OTSConditionCheckFail")) {
                return false;
            }
        }
        throw ex;
    }
    return true;
}

@Test
public void testCheckNullSucceeded() throws IOException {
    clean();

    Put put = new Put(Bytes.toBytes("pk0"));
    put.addColumn(Bytes.toBytes(familyName), Bytes.toBytes("col_1"), Bytes.toBytes("col_1_var"));

    RowMutations mutaions = new RowMutations(Bytes.toBytes("pk0"));
    mutaions.add(put);

    table.checkAndMutate(Bytes.toBytes("pk0"), Bytes.toBytes(familyName), Bytes.toBytes("col_1"), CompareFilter.CompareOp.EQUAL,
            null, mutaions);

    Get get = new Get(Bytes.toBytes("pk0"));
    Result result = table.get(get);
    String value = Bytes.toString(result.getValue(Bytes.toBytes(familyName), Bytes.toBytes("col_1")));
    assertEquals("col_1_var", value);
}

@Test
public void testMutationWithOneDelete() throws IOException {
    clean();

    Put put = new Put(Bytes.toBytes("pk0"));
    put.addColumn(Bytes.toBytes(familyName), Bytes.toBytes("col_1"), Bytes.toBytes("col_1_var"));
    put.addColumn(Bytes.toBytes(familyName), Bytes.toBytes("col_2"), Bytes.toBytes("col_2_var"));
    table.put(put);


    Delete delete = new Delete(Bytes.toBytes("pk0"));
    delete.addColumns(Bytes.toBytes(familyName), Bytes.toBytes("col_2"));

    RowMutations mutaions = new RowMutations(Bytes.toBytes("pk0"));
    mutaions.add(delete);

    table.checkAndMutate(Bytes.toBytes("pk0"), Bytes.toBytes(familyName), Bytes.toBytes("col_1"), CompareFilter.CompareOp.GREATER_OR_EQUAL,
            Bytes.toBytes("col_1_var"), mutaions);

    Get get = new Get(Bytes.toBytes("pk0"));
    Result result = table.get(get);
    String value = Bytes.toString(result.getValue(Bytes.toBytes(familyName), Bytes.toBytes("col_1")));
    assertEquals("col_1_var", value);
    byte[] col2 = result.getValue(Bytes.toBytes(familyName), Bytes.toBytes("col_2"));
    assertTrue(col2 == null);
}

@Test
public void testTwoFilterWithMustAllPassFailed() throws IOException {
    clean();
    {
        Put put = new Put(Bytes.toBytes(rowPrefix));
        put.addColumn(Bytes.toBytes(familyName), Bytes.toBytes("col_1"), Bytes.toBytes("col_1_var"));
        put.addColumn(Bytes.toBytes(familyName), Bytes.toBytes("col_2"), Bytes.toBytes("col_2_var"));
        table.put(put);
    }

    {
        Get get = new Get(Bytes.toBytes(rowPrefix));
        Filter filter1 = new SingleColumnValueFilter(Bytes.toBytes(familyName), Bytes.toBytes("col_1"),
                CompareFilter.CompareOp.EQUAL, Bytes.toBytes("col_1_var"));
        Filter filter2 = new SingleColumnValueFilter(Bytes.toBytes(familyName), Bytes.toBytes("col_2"),
                CompareFilter.CompareOp.NOT_EQUAL, Bytes.toBytes("col_2_var"));
        FilterList filterList = new FilterList(FilterList.Operator.MUST_PASS_ALL);
        filterList.addFilter(filter1);
        filterList.addFilter(filter2);

        get.setFilter(filterList);
        Result result = table.get(get);
        assertTrue(result.getRow() == null);
    }
}

@Test
public void testTwoFilterWithMustOnePassFailed() throws IOException {
    clean();
    {
        Put put = new Put(Bytes.toBytes(rowPrefix));
        put.addColumn(Bytes.toBytes(familyName), Bytes.toBytes("col_1"), Bytes.toBytes("col_1_var"));
        put.addColumn(Bytes.toBytes(familyName), Bytes.toBytes("col_2"), Bytes.toBytes("col_2_var"));
        table.put(put);
    }

    {
        Get get = new Get(Bytes.toBytes(rowPrefix));
        Filter filter1 = new SingleColumnValueFilter(Bytes.toBytes(familyName), Bytes.toBytes("col_1"),
                CompareFilter.CompareOp.NOT_EQUAL, Bytes.toBytes("col_1_var"));
        Filter filter2 = new SingleColumnValueFilter(Bytes.toBytes(familyName), Bytes.toBytes("col_2"),
                CompareFilter.CompareOp.NOT_EQUAL, Bytes.toBytes("col_2_var"));
        FilterList filterList = new FilterList(FilterList.Operator.MUST_PASS_ALL);
        filterList.addFilter(filter1);
        filterList.addFilter(filter2);

        get.setFilter(filterList);
        Result result = table.get(get);
        assertTrue(result.getRow() == null);
    }
}

@Test
public void testEqualAndSuccess2() throws IOException {
    clean();

    String row = rowPrefix;
    {
        Put put = new Put(Bytes.toBytes(row));
        put.addColumn(Bytes.toBytes(familyName), Bytes.toBytes("col_1"), Bytes.toBytes("val_1"));

        table.put(put);
    }

    Delete delete = new Delete(Bytes.toBytes(row));

    boolean ret = table.checkAndDelete(Bytes.toBytes(row), Bytes.toBytes(familyName), Bytes.toBytes("col_1"),
            CompareFilter.CompareOp.EQUAL, Bytes.toBytes("val_1"), delete);
    assertTrue(ret);

    Get get = new Get(Bytes.toBytes(row));
    byte[] result = table.get(get).getRow();
    assertTrue(result == null);
}

@Test
public void testEqualAndFailed2() throws IOException {
    clean();

    String row = rowPrefix;
    {
        Put put = new Put(Bytes.toBytes(row));
        put.addColumn(Bytes.toBytes(familyName), Bytes.toBytes("col_1"), Bytes.toBytes("val_1"));

        table.put(put);
    }

    Delete delete = new Delete(Bytes.toBytes(row));

    boolean ret = table.checkAndDelete(Bytes.toBytes(row), Bytes.toBytes(familyName), Bytes.toBytes("col_1"),
            CompareFilter.CompareOp.EQUAL, Bytes.toBytes("val_3"), delete);
    assertTrue(!ret);

    Get get = new Get(Bytes.toBytes(row));
    byte[] result = table.get(get).getRow();
    assertTrue(result != null);
}

@Test
public void testNotEqualAndSuccess() throws IOException {
    clean();

    String row = rowPrefix;
    {
        Put put = new Put(Bytes.toBytes(row));
        put.addColumn(Bytes.toBytes(familyName), Bytes.toBytes("col_1"), Bytes.toBytes("val_1"));

        table.put(put);
    }

    Delete delete = new Delete(Bytes.toBytes(row));

    boolean ret = table.checkAndDelete(Bytes.toBytes(row), Bytes.toBytes(familyName), Bytes.toBytes("col_1"),
            CompareFilter.CompareOp.NOT_EQUAL, Bytes.toBytes("val_3"), delete);
    assertTrue(ret);

    Get get = new Get(Bytes.toBytes(row));
    byte[] result = table.get(get).getRow();
    assertTrue(result == null);
}

@Test
public void testNotEqualAndFailed() throws IOException {
    clean();

    String row = rowPrefix;
    {
        Put put = new Put(Bytes.toBytes(row));
        put.addColumn(Bytes.toBytes(familyName), Bytes.toBytes("col_1"), Bytes.toBytes("val_1"));

        table.put(put);
    }

    Delete delete = new Delete(Bytes.toBytes(row));

    boolean ret = table.checkAndDelete(Bytes.toBytes(row), Bytes.toBytes(familyName), Bytes.toBytes("col_1"),
            CompareFilter.CompareOp.NOT_EQUAL, Bytes.toBytes("val_1"), delete);
    assertTrue(!ret);

    Get get = new Get(Bytes.toBytes(row));
    byte[] result = table.get(get).getRow();
    assertTrue(result != null);
}

@Test
public void testGreaterAndSuccess() throws IOException {
    clean();

    String row = rowPrefix;
    {
        Put put = new Put(Bytes.toBytes(row));
        put.addColumn(Bytes.toBytes(familyName), Bytes.toBytes("col_1"), Bytes.toBytes("val_1"));

        table.put(put);
    }

    Delete delete = new Delete(Bytes.toBytes(row));

    boolean ret = table.checkAndDelete(Bytes.toBytes(row), Bytes.toBytes(familyName), Bytes.toBytes("col_1"),
            CompareFilter.CompareOp.GREATER, Bytes.toBytes("val_0"), delete);
    assertTrue(ret);

    Get get = new Get(Bytes.toBytes(row));
    byte[] result = table.get(get).getRow();
    assertTrue(result == null);
}

@Test
public void testGreaterAndFailed() throws IOException {
    clean();

    String row = rowPrefix;
    {
        Put put = new Put(Bytes.toBytes(row));
        put.addColumn(Bytes.toBytes(familyName), Bytes.toBytes("col_1"), Bytes.toBytes("val_1"));

        table.put(put);
    }

    Delete  delete = new Delete(Bytes.toBytes(row));

    boolean ret = table.checkAndDelete(Bytes.toBytes(row), Bytes.toBytes(familyName), Bytes.toBytes("col_1"),
            CompareFilter.CompareOp.GREATER, Bytes.toBytes("val_1"), delete);
    assertTrue(!ret);

    Get get = new Get(Bytes.toBytes(row));
    byte[] result = table.get(get).getRow();
    assertTrue(result != null);
}

@Test
public void testGreaterOrEqualAndSuccess() throws IOException {
    clean();

    String row = rowPrefix;
    {
        Put put = new Put(Bytes.toBytes(row));
        put.addColumn(Bytes.toBytes(familyName), Bytes.toBytes("col_1"), Bytes.toBytes("val_1"));

        table.put(put);
    }

    Delete delete = new Delete(Bytes.toBytes(row));

    boolean ret = table.checkAndDelete(Bytes.toBytes(row), Bytes.toBytes(familyName), Bytes.toBytes("col_1"),
            CompareFilter.CompareOp.GREATER_OR_EQUAL, Bytes.toBytes("val_0"), delete);
    assertTrue(ret);

    Get get = new Get(Bytes.toBytes(row));
    byte[] result = table.get(get).getRow();
    assertTrue(result == null);
}

@Test
public void testGreaterOrEqualAndFailed() throws IOException {
    clean();

    String row = rowPrefix;
    {
        Put put = new Put(Bytes.toBytes(row));
        put.addColumn(Bytes.toBytes(familyName), Bytes.toBytes("col_1"), Bytes.toBytes("val_1"));

        table.put(put);
    }

    Delete delete = new Delete(Bytes.toBytes(row));

    boolean ret = table.checkAndDelete(Bytes.toBytes(row), Bytes.toBytes(familyName), Bytes.toBytes("col_1"),
            CompareFilter.CompareOp.GREATER_OR_EQUAL, Bytes.toBytes("val_4"), delete);
    assertTrue(!ret);

    Get get = new Get(Bytes.toBytes(row));
    byte[] result = table.get(get).getRow();
    assertTrue(result != null);
}

@Test
public void testLessAndSuccess() throws IOException {
    clean();

    String row = rowPrefix;
    {
        Put put = new Put(Bytes.toBytes(row));
        put.addColumn(Bytes.toBytes(familyName), Bytes.toBytes("col_1"), Bytes.toBytes("val_1"));

        table.put(put);
    }

    Delete delete = new Delete(Bytes.toBytes(row));

    boolean ret = table.checkAndDelete(Bytes.toBytes(row), Bytes.toBytes(familyName), Bytes.toBytes("col_1"),
            CompareFilter.CompareOp.LESS, Bytes.toBytes("val_5"), delete);
    assertTrue(ret);

    Get get = new Get(Bytes.toBytes(row));
    byte[] result = table.get(get).getRow();
    assertTrue(result == null);
}

@Test
public void testLessAndFailed() throws IOException {
    clean();

    String row = rowPrefix;
    {
        Put put = new Put(Bytes.toBytes(row));
        put.addColumn(Bytes.toBytes(familyName), Bytes.toBytes("col_1"), Bytes.toBytes("val_1"));

        table.put(put);
    }

    Delete delete = new Delete(Bytes.toBytes(row));

    boolean ret = table.checkAndDelete(Bytes.toBytes(row), Bytes.toBytes(familyName), Bytes.toBytes("col_1"),
            CompareFilter.CompareOp.LESS, Bytes.toBytes("val_0"), delete);
    assertTrue(!ret);

    Get get = new Get(Bytes.toBytes(row));
    byte[] result = table.get(get).getRow();
    assertTrue(result != null);
}

@Test
public void testLessOrEqualAndSuccess() throws IOException {
    clean();

    String row = rowPrefix;
    {
        Put put = new Put(Bytes.toBytes(row));
        put.addColumn(Bytes.toBytes(familyName), Bytes.toBytes("col_1"), Bytes.toBytes("val_1"));

        table.put(put);
    }

    Delete delete = new Delete(Bytes.toBytes(row));

    boolean ret = table.checkAndDelete(Bytes.toBytes(row), Bytes.toBytes(familyName), Bytes.toBytes("col_1"),
            CompareFilter.CompareOp.LESS_OR_EQUAL, Bytes.toBytes("val_5"), delete);
    assertTrue(ret);

    Get get = new Get(Bytes.toBytes(row));
    byte[] result = table.get(get).getRow();
    assertTrue(result == null);
}

@Test
public void testLessOrEqualAndFailed() throws IOException {
    clean();

    String row = rowPrefix;
    {
        Put put = new Put(Bytes.toBytes(row));
        put.addColumn(Bytes.toBytes(familyName), Bytes.toBytes("col_1"), Bytes.toBytes("val_1"));

        table.put(put);
    }

    Delete delete = new Delete(Bytes.toBytes(row));

    boolean ret = table.checkAndDelete(Bytes.toBytes(row), Bytes.toBytes(familyName), Bytes.toBytes("col_1"),
            CompareFilter.CompareOp.LESS_OR_EQUAL, Bytes.toBytes("val_0"), delete);
    assertTrue(!ret);

    Get get = new Get(Bytes.toBytes(row));
    byte[] result = table.get(get).getRow();
    assertTrue(result != null);
}

private void doRawScan() throws IOException {
  FilterList filterList = new FilterList();
  CompareFilter.CompareOp startOp = CompareFilter.CompareOp.GREATER_OR_EQUAL;
  CompareFilter.CompareOp stopOp = CompareFilter.CompareOp.LESS_OR_EQUAL;
  for (int i = 0; i < indexColumnNames.length && i < scanValues.length; i++) {
    filterList.addFilter(
        new SingleColumnValueFilter(familyName, Bytes.toBytes(indexColumnNames[i]), startOp,
            Bytes.toBytes(scanValues[i][0])));
    filterList.addFilter(
        new SingleColumnValueFilter(familyName, Bytes.toBytes(indexColumnNames[i]), stopOp,
            Bytes.toBytes(scanValues[i][1])));
  }
  Scan scan = new Scan();
  scan.setFilter(filterList);
  scan.setId("raw-scan");
  Table table = conn.getTable(tableName);
  ResultScanner scanner = table.getScanner(scan);
  Result result;
  int count = 0;
  while ((result = scanner.next()) != null) {
    ++count;
    if (PRINT_RESULT) printResult(result);
  }
  scanner.close();
  System.out.println("raw scan has " + count + " records");
}

@Override
public boolean preCheckAndPutAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
    final byte[] row, final byte[] family, final byte[] qualifier,
    final CompareFilter.CompareOp compareOp, final ByteArrayComparable comparator, final Put put,
    final boolean result) throws IOException {
  if (put.getAttribute(CHECK_COVERING_PERM) != null) {
    // We had failure with table, cf and q perm checks and now giving a chance for cell
    // perm check
    TableName table = c.getEnvironment().getRegion().getRegionInfo().getTable();
    Map<byte[], ? extends Collection<byte[]>> families = makeFamilyMap(family, qualifier);
    AuthResult authResult = null;
    if (checkCoveringPermission(OpType.CHECK_AND_PUT, c.getEnvironment(), row, families,
        HConstants.LATEST_TIMESTAMP, Action.READ)) {
      authResult = AuthResult.allow(OpType.CHECK_AND_PUT.toString(), "Covering cell set",
          getActiveUser(), Action.READ, table, families);
    } else {
      authResult = AuthResult.deny(OpType.CHECK_AND_PUT.toString(), "Covering cell set",
          getActiveUser(), Action.READ, table, families);
    }
    logResult(authResult);
    if (authorizationEnabled && !authResult.isAllowed()) {
      throw new AccessDeniedException("Insufficient permissions " + authResult.toContextString());
    }
  }
  return result;
}

protected Scan constructScan(byte[] valuePrefix) throws IOException {
  FilterList list = new FilterList();
  Filter filter = new SingleColumnValueFilter(
      FAMILY_NAME, COLUMN_ZERO, CompareFilter.CompareOp.EQUAL,
      new BinaryComparator(valuePrefix)
  );
  list.addFilter(filter);
  if(opts.filterAll) {
    list.addFilter(new FilterAllFilter());
  }
  Scan scan = new Scan();
  scan.setCaching(opts.caching);
  if (opts.addColumns) {
    scan.addColumn(FAMILY_NAME, QUALIFIER_NAME);
  } else {
    scan.addFamily(FAMILY_NAME);
  }
  scan.setFilter(list);
  return scan;
}

@Test
public void testJira6912() throws Exception {
  TableName TABLE = TableName.valueOf("testJira6912");
  Table foo = TEST_UTIL.createTable(TABLE, new byte[][] {FAMILY}, 10);

  List<Put> puts = new ArrayList<Put>();
  for (int i=0;i !=100; i++){
    Put put = new Put(Bytes.toBytes(i));
    put.add(FAMILY, FAMILY, Bytes.toBytes(i));
    puts.add(put);
  }
  foo.put(puts);
  // If i comment this out it works
  TEST_UTIL.flush();

  Scan scan = new Scan();
  scan.setStartRow(Bytes.toBytes(1));
  scan.setStopRow(Bytes.toBytes(3));
  scan.addColumn(FAMILY, FAMILY);
  scan.setFilter(new RowFilter(CompareFilter.CompareOp.NOT_EQUAL, new BinaryComparator(Bytes.toBytes(1))));

  ResultScanner scanner = foo.getScanner(scan);
  Result[] bar = scanner.next(100);
  assertEquals(1, bar.length);
}

private void runScanner(Table table, boolean slow) throws Exception {
  long time = System.nanoTime();
  Scan scan = new Scan();
  scan.addColumn(cf_essential, col_name);
  scan.addColumn(cf_joined, col_name);

  SingleColumnValueFilter filter = new SingleColumnValueFilter(
      cf_essential, col_name, CompareFilter.CompareOp.EQUAL, flag_yes);
  filter.setFilterIfMissing(true);
  scan.setFilter(filter);
  scan.setLoadColumnFamiliesOnDemand(!slow);

  ResultScanner result_scanner = table.getScanner(scan);
  Result res;
  long rows_count = 0;
  while ((res = result_scanner.next()) != null) {
    rows_count++;
  }

  double timeSec = (System.nanoTime() - time) / 1000000000.0;
  result_scanner.close();
  LOG.info((slow ? "Slow" : "Joined") + " scanner finished in " + Double.toString(timeSec)
    + " seconds, got " + Long.toString(rows_count/2) + " rows");
}

@Override public void readFields(DataInput in) throws IOException {
  family = Bytes.readByteArray(in);
  qualifier = Bytes.readByteArray(in);
  boolean startNull = Bytes.toBoolean(Bytes.readByteArray(in));
  if (startNull) {
    start = null;
    startOp = CompareFilter.CompareOp.NO_OP;
  } else {
    start = Bytes.readByteArray(in);
    startOp = CompareFilter.CompareOp.valueOf(Bytes.toString(Bytes.readByteArray(in)));
  }
  boolean stopNull = Bytes.toBoolean(Bytes.readByteArray(in));
  if (stopNull) {
    stop = null;
    stopOp = CompareFilter.CompareOp.NO_OP;
  } else {
    stop = Bytes.readByteArray(in);
    stopOp = CompareFilter.CompareOp.valueOf(Bytes.toString(Bytes.readByteArray(in)));
  }
  startTs = in.readLong();
  stopTs = in.readLong();
  dataType = DataType.valueOf(Bytes.toString(Bytes.readByteArray(in)));
}

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

    if (where == Where.NotEquals)
        return CompareFilter.CompareOp.NOT_EQUAL;

    if (where == Where.Less)
        return CompareFilter.CompareOp.LESS;

    if (where == Where.LessEquals)
        return CompareFilter.CompareOp.LESS_OR_EQUAL;

    if (where == Where.Greater)
        return CompareFilter.CompareOp.GREATER;

    if (where == Where.GreaterEquals)
        return CompareFilter.CompareOp.GREATER_OR_EQUAL;

    return CompareFilter.CompareOp.EQUAL;
}

private FilterList getColumnValueFilters(Row row) {
  FilterList filterList = new FilterList(Operator.MUST_PASS_ALL);
  Set<String> filterColumnNames = Sets.newHashSet(row.schema().fieldNames());

  for (Map.Entry<String, ColumnDef> column : columns.entrySet()) {
    if (!column.getValue().cf.equals("rowkey")) {
      if (filterColumnNames.contains(column.getKey())) {
        byte[] value = getColumnValueAsBytes(column.getValue().name, column.getValue().type, row);
        if (value != null) {
          SingleColumnValueFilter columnValueFilter = new SingleColumnValueFilter(
              Bytes.toBytes(column.getValue().cf),
              Bytes.toBytes(column.getValue().name),
              CompareFilter.CompareOp.EQUAL,
              value
          );
          filterList.addFilter(columnValueFilter);
        }
      }
    }
  }

  return filterList;
}

/**
 * Applies the message to {@link org.apache.hadoop.hbase.filter.Filter} to context.
 */
@Override
public void apply(CamelContext context, HBaseRow rowModel) {
    fl.getFilters().clear();
    if (rowModel != null) {
        for (HBaseCell cell : rowModel.getCells()) {
            if (cell.getValue() != null) {
                byte[] family = HBaseHelper.getHBaseFieldAsBytes(cell.getFamily());
                byte[] qualifier = HBaseHelper.getHBaseFieldAsBytes(cell.getQualifier());
                byte[] value = context.getTypeConverter().convertTo(byte[].class, cell.getValue());
                SingleColumnValueFilter columnValueFilter = new SingleColumnValueFilter(family, qualifier, CompareFilter.CompareOp.EQUAL, value);
                fl.addFilter(columnValueFilter);
            }
        }
    }
}

@Test
public void testJira6912() throws Exception {
  byte [] TABLE = Bytes.toBytes("testJira6912");
  HTable foo = TEST_UTIL.createTable(TABLE, new byte[][] {FAMILY}, 10);

  List<Put> puts = new ArrayList<Put>();
  for (int i=0;i !=100; i++){
    Put put = new Put(Bytes.toBytes(i));
    put.add(FAMILY, FAMILY, Bytes.toBytes(i));
    puts.add(put);
  }
  foo.put(puts);
  // If i comment this out it works
  TEST_UTIL.flush();

  Scan scan = new Scan();
  scan.setStartRow(Bytes.toBytes(1));
  scan.setStopRow(Bytes.toBytes(3));
  scan.addColumn(FAMILY, FAMILY);
  scan.setFilter(new RowFilter(CompareFilter.CompareOp.NOT_EQUAL, new BinaryComparator(Bytes.toBytes(1))));

  ResultScanner scanner = foo.getScanner(scan);
  Result[] bar = scanner.next(100);
  assertEquals(1, bar.length);
}

protected void addTimeConstraints(Scan scan)
{
    List<Filter> filters = new ArrayList<>();

    if(context.getQuery().getAfter() != null)
    {
        filters.add(new SingleColumnValueFilter(Schema.F_INFO, Schema.Q_EPOCH, CompareFilter.CompareOp.GREATER_OR_EQUAL, Bytes.toBytes(context.getQuery().getAfter())));
    }

    if(context.getQuery().getBefore() != null)
    {
        filters.add(new SingleColumnValueFilter(Schema.F_INFO, Schema.Q_EPOCH, CompareFilter.CompareOp.LESS_OR_EQUAL, Bytes.toBytes(context.getQuery().getBefore())));
    }

    if(!filters.isEmpty())
    {
        FilterList filterList = new FilterList(FilterList.Operator.MUST_PASS_ALL, filters);
        scan.setFilter(filterList);
    }
}

public static PostfixFilter parseFrom(final byte[] bytes) throws DeserializationException
{
    CustomFilterProtos.PostfixFilter proto;
    try
    {
        proto = CustomFilterProtos.PostfixFilter.parseFrom(bytes);
    }
    catch (InvalidProtocolBufferException e)
    {
        throw new DeserializationException(e);
    }

    final CompareFilter.CompareOp compareOp = CompareFilter.CompareOp.values()[proto.getCompareOp()];
    final int offset = proto.getOffset();
    final byte[] postfix = proto.getPostfix().toByteArray();

    return new PostfixFilter(compareOp, postfix, offset);
}

@Test
public void latestVersionOnlyComparisonsAreDone() throws IOException {
  byte[] filterValue = Bytes.toBytes("foobar");
  byte[] qualifier = Bytes.toBytes("someColumn");
  byte[] family = Bytes.toBytes("f");

  SingleColumnValueFilter filter = new SingleColumnValueFilter(
      family,
      qualifier,
      CompareFilter.CompareOp.EQUAL,
      new BinaryComparator(filterValue));

  filter.setFilterIfMissing(false);
  filter.setLatestVersionOnly(true);

  RowFilter adaptedFilter = adapter.adapt(
      new FilterAdapterContext(new Scan()),
      filter);

  assertFilterIfNotMIssingMatches(
      family,
      qualifier,
      filterValue,
      1 /* latest version only = true */,
      adaptedFilter);
}

@Test
public void allVersionComparisonAreDone() throws IOException {
  byte[] filterValue = Bytes.toBytes("foobar");
  byte[] qualifier = Bytes.toBytes("someColumn");
  byte[] family = Bytes.toBytes("f");

  SingleColumnValueFilter filter = new SingleColumnValueFilter(
      family,
      qualifier,
      CompareFilter.CompareOp.EQUAL,
      new BinaryComparator(filterValue));

  filter.setFilterIfMissing(false);
  filter.setLatestVersionOnly(false);

  RowFilter adaptedFilter = adapter.adapt(
      new FilterAdapterContext(new Scan()),
      filter);

  assertFilterIfNotMIssingMatches(
      family,
      qualifier,
      filterValue,
      Integer.MAX_VALUE /* latest version only = false */,
      adaptedFilter);
}

@Override
public boolean preCheckAndPutAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
    final byte[] row, final byte[] family, final byte[] qualifier,
    final CompareFilter.CompareOp compareOp, final ByteArrayComparable comparator, final Put put,
    final boolean result) throws IOException {
  if (put.getAttribute(CHECK_COVERING_PERM) != null) {
    // We had failure with table, cf and q perm checks and now giving a chance for cell
    // perm check
    TableName table = c.getEnvironment().getRegion().getRegionInfo().getTable();
    Map<byte[], ? extends Collection<byte[]>> families = makeFamilyMap(family, qualifier);
    AuthResult authResult = null;
    if (checkCoveringPermission(OpType.CHECK_AND_PUT, c.getEnvironment(), row, families,
        HConstants.LATEST_TIMESTAMP, Action.READ)) {
      authResult = AuthResult.allow(OpType.CHECK_AND_PUT.toString(), "Covering cell set",
          getActiveUser(), Action.READ, table, families);
    } else {
      authResult = AuthResult.deny(OpType.CHECK_AND_PUT.toString(), "Covering cell set",
          getActiveUser(), Action.READ, table, families);
    }
    logResult(authResult);
    if (!authResult.isAllowed()) {
      throw new AccessDeniedException("Insufficient permissions " + authResult.toContextString());
    }
  }
  return result;
}

@Test
public void testJira6912() throws Exception {
  TableName TABLE = TableName.valueOf("testJira6912");
  Table foo = TEST_UTIL.createTable(TABLE, new byte[][] {FAMILY}, 10);

  List<Put> puts = new ArrayList<Put>();
  for (int i=0;i !=100; i++){
    Put put = new Put(Bytes.toBytes(i));
    put.add(FAMILY, FAMILY, Bytes.toBytes(i));
    puts.add(put);
  }
  foo.put(puts);
  // If i comment this out it works
  TEST_UTIL.flush();

  Scan scan = new Scan();
  scan.setStartRow(Bytes.toBytes(1));
  scan.setStopRow(Bytes.toBytes(3));
  scan.addColumn(FAMILY, FAMILY);
  scan.setFilter(new RowFilter(CompareFilter.CompareOp.NOT_EQUAL, new BinaryComparator(Bytes.toBytes(1))));

  ResultScanner scanner = foo.getScanner(scan);
  Result[] bar = scanner.next(100);
  assertEquals(1, bar.length);
}

private void runScanner(Table table, boolean slow) throws Exception {
  long time = System.nanoTime();
  Scan scan = new Scan();
  scan.addColumn(cf_essential, col_name);
  scan.addColumn(cf_joined, col_name);

  SingleColumnValueFilter filter = new SingleColumnValueFilter(
      cf_essential, col_name, CompareFilter.CompareOp.EQUAL, flag_yes);
  filter.setFilterIfMissing(true);
  scan.setFilter(filter);
  scan.setLoadColumnFamiliesOnDemand(!slow);

  ResultScanner result_scanner = table.getScanner(scan);
  Result res;
  long rows_count = 0;
  while ((res = result_scanner.next()) != null) {
    rows_count++;
  }

  double timeSec = (System.nanoTime() - time) / 1000000000.0;
  result_scanner.close();
  LOG.info((slow ? "Slow" : "Joined") + " scanner finished in " + Double.toString(timeSec)
    + " seconds, got " + Long.toString(rows_count/2) + " rows");
}

@Test
public void testJira6912() throws Exception {
  byte [] TABLE = Bytes.toBytes("testJira6912");
  HTable foo = TEST_UTIL.createTable(TABLE, new byte[][] {FAMILY}, 10);

  List<Put> puts = new ArrayList<Put>();
  for (int i=0;i !=100; i++){
    Put put = new Put(Bytes.toBytes(i));
    put.add(FAMILY, FAMILY, Bytes.toBytes(i));
    puts.add(put);
  }
  foo.put(puts);
  // If i comment this out it works
  TEST_UTIL.flush();

  Scan scan = new Scan();
  scan.setStartRow(Bytes.toBytes(1));
  scan.setStopRow(Bytes.toBytes(3));
  scan.addColumn(FAMILY, FAMILY);
  scan.setFilter(new RowFilter(CompareFilter.CompareOp.NOT_EQUAL, new BinaryComparator(Bytes.toBytes(1))));

  ResultScanner scanner = foo.getScanner(scan);
  Result[] bar = scanner.next(100);
  assertEquals(1, bar.length);
}

private void runScanner(HTable table, boolean slow) throws Exception {
  long time = System.nanoTime();
  Scan scan = new Scan();
  scan.addColumn(cf_essential, col_name);
  scan.addColumn(cf_joined, col_name);

  SingleColumnValueFilter filter = new SingleColumnValueFilter(
      cf_essential, col_name, CompareFilter.CompareOp.EQUAL, flag_yes);
  filter.setFilterIfMissing(true);
  scan.setFilter(filter);
  scan.setLoadColumnFamiliesOnDemand(!slow);

  ResultScanner result_scanner = table.getScanner(scan);
  Result res;
  long rows_count = 0;
  while ((res = result_scanner.next()) != null) {
    rows_count++;
  }

  double timeSec = (System.nanoTime() - time) / 1000000000.0;
  result_scanner.close();
  LOG.info((slow ? "Slow" : "Joined") + " scanner finished in " + Double.toString(timeSec)
    + " seconds, got " + Long.toString(rows_count/2) + " rows");
}

@Test
public void testJira6912() throws Exception {
  byte [] TABLE = Bytes.toBytes("testJira6912");
  HTable foo = TEST_UTIL.createTable(TABLE, new byte[][] {FAMILY}, 10);

  List<Put> puts = new ArrayList<Put>();
  for (int i=0;i !=100; i++){
    Put put = new Put(Bytes.toBytes(i));
    put.add(FAMILY, FAMILY, Bytes.toBytes(i));
    puts.add(put);
  }
  foo.put(puts);
  // If i comment this out it works
  TEST_UTIL.flush();

  Scan scan = new Scan();
  scan.setStartRow(Bytes.toBytes(1));
  scan.setStopRow(Bytes.toBytes(3));
  scan.addColumn(FAMILY, FAMILY);
  scan.setFilter(new RowFilter(CompareFilter.CompareOp.NOT_EQUAL, new BinaryComparator(Bytes.toBytes(1))));

  ResultScanner scanner = foo.getScanner(scan);
  Result[] bar = scanner.next(100);
  assertEquals(1, bar.length);
}

private void runScanner(Table table, boolean slow) throws Exception {
  long time = System.nanoTime();
  Scan scan = new Scan();
  scan.addColumn(cf_essential, col_name);
  scan.addColumn(cf_joined, col_name);

  SingleColumnValueFilter filter = new SingleColumnValueFilter(
      cf_essential, col_name, CompareFilter.CompareOp.EQUAL, flag_yes);
  filter.setFilterIfMissing(true);
  scan.setFilter(filter);
  scan.setLoadColumnFamiliesOnDemand(!slow);

  ResultScanner result_scanner = table.getScanner(scan);
  Result res;
  long rows_count = 0;
  while ((res = result_scanner.next()) != null) {
    rows_count++;
  }

  double timeSec = (System.nanoTime() - time) / 1000000000.0;
  result_scanner.close();
  LOG.info((slow ? "Slow" : "Joined") + " scanner finished in " + Double.toString(timeSec)
    + " seconds, got " + Long.toString(rows_count/2) + " rows");
}