Java CompareFilter类代码示例

import org.apache.hadoop.hbase.filter.CompareFilter; //导入依赖的package包/类
@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;
}
 

import org.apache.hadoop.hbase.filter.CompareFilter; //导入依赖的package包/类
@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;
}
 

import org.apache.hadoop.hbase.filter.CompareFilter; //导入依赖的package包/类
@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;
}
 

import org.apache.hadoop.hbase.filter.CompareFilter; //导入依赖的package包/类
@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);
}
 

import org.apache.hadoop.hbase.filter.CompareFilter; //导入依赖的package包/类
@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);
}
 

import org.apache.hadoop.hbase.filter.CompareFilter; //导入依赖的package包/类
@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);
    }
}
 

import org.apache.hadoop.hbase.filter.CompareFilter; //导入依赖的package包/类
@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);
    }
}
 

import org.apache.hadoop.hbase.filter.CompareFilter; //导入依赖的package包/类
@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);
}
 

import org.apache.hadoop.hbase.filter.CompareFilter; //导入依赖的package包/类
@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);
}
 

import org.apache.hadoop.hbase.filter.CompareFilter; //导入依赖的package包/类
@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);
}
 

import org.apache.hadoop.hbase.filter.CompareFilter; //导入依赖的package包/类
@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);
}
 

import org.apache.hadoop.hbase.filter.CompareFilter; //导入依赖的package包/类
@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);
}
 

import org.apache.hadoop.hbase.filter.CompareFilter; //导入依赖的package包/类
@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);
}
 

import org.apache.hadoop.hbase.filter.CompareFilter; //导入依赖的package包/类
@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);
}
 

import org.apache.hadoop.hbase.filter.CompareFilter; //导入依赖的package包/类
@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);
}