[Hbase]Hbase的过滤器分类

桃扇骨 2022-05-08 00:10 207阅读 0赞

## Hbase的过滤器分类 ##

### 1、比较过滤器 ###

1.1、行键过滤器RowFilter

Filter filter1 = new RowFilter(CompareOp.LESS_OR_EQUAL, new BinaryComparator(Bytes.toBytes("row-22")));  
    scan.setFilter(filter1);

1.2、列族过滤器FamilyFilter

Filter filter1 = new FamilyFilter(CompareFilter.CompareOp.LESS, new BinaryComparator(Bytes.toBytes("colfam3")));
    scan.setFilter(filter1);

1.3、列过滤器QualifierFilter

filter = new QualifierFilter(CompareFilter.CompareOp.LESS_OR_EQUAL, new BinaryComparator(Bytes.toBytes("col-2")));
    scan.setFilter(filter1);

1.4、值过滤器ValueFilter

Filter filter = new ValueFilter(CompareFilter.CompareOp.EQUAL, new SubstringComparator(".4") );  
    scan.setFilter(filter1);

### 2、专用过滤器 ###

2.1、单列值过滤器SingleColumnValueFilter

返回满足条件的整行

SingleColumnValueFilter filter = new SingleColumnValueFilter(  
        Bytes.toBytes("colfam1"),  
        Bytes.toBytes("col-5"),  
        CompareFilter.CompareOp.NOT_EQUAL,  
        new SubstringComparator("val-5"));  
    filter.setFilterIfMissing(true);  //如果不设置为true，则那些不包含指定column的行也会返回
    scan.setFilter(filter1);

2.2、SingleColumnValueExcludeFilter与SingleColumnValueFilter相反

2.3、前缀过滤器PrefixFilter

针对行键

Filter filter = new PrefixFilter(Bytes.toBytes("row1"));  
    scan.setFilter(filter1);

2.4、列前缀过滤器ColumnPrefixFilter

Filter filter = new ColumnPrefixFilter(Bytes.toBytes("qual2"));  
    scan.setFilter(filter1);

2.5、分页过滤器PageFilter

public static void main(String[] args) throws Exception {
            Configuration conf = HBaseConfiguration.create();
            conf.set("hbase.zookeeper.quorum", "spark01:2181,spark02:2181,spark03:2181");
    
            String tableName = "testfilter";  
            String cfName = "f1";  
            final byte[] POSTFIX = new byte[] { 0x00 };  
            HTable table = new HTable(conf, tableName);  
            Filter filter = new PageFilter(3);  
            byte[] lastRow = null;  
            int totalRows = 0;  
            while (true) {  
                Scan scan = new Scan();  
                scan.setFilter(filter);  
                if(lastRow != null){  
                    //注意这里添加了POSTFIX操作，用来重置扫描边界  
                    byte[] startRow = Bytes.add(lastRow,POSTFIX);  
                    scan.setStartRow(startRow);  
                }  
                ResultScanner scanner = table.getScanner(scan);  
                int localRows = 0;  
                Result result;  
                while((result = scanner.next()) != null){  
                    System.out.println(localRows++ + ":" + result);  
                    totalRows ++;  
                    lastRow = result.getRow();  
                }  
                scanner.close();  
                if(localRows == 0) break;  
            }  
            System.out.println("total rows:" + totalRows);  
        }

### 3、多种过滤条件使用 ###

/**
         * 多种过滤条件的使用方法
         * @throws Exception
         */
        @Test
        public void testScan() throws Exception{
            HTable table = new HTable(conf, "person_info".getBytes());
            Scan scan = new Scan(Bytes.toBytes("person_rk_bj_zhang_000001"), Bytes.toBytes("person_rk_bj_zhang_000002"));
    
            //前缀过滤器----针对行键
            Filter filter = new PrefixFilter(Bytes.toBytes("rk"));
    
            //行过滤器  ---针对行键
            ByteArrayComparable rowComparator = new BinaryComparator(Bytes.toBytes("person_rk_bj_zhang_000001"));
            RowFilter rf = new RowFilter(CompareOp.LESS_OR_EQUAL, rowComparator);
    
            /**
             * 假设rowkey格式为：创建日期_发布日期_ID_TITLE
             * 目标：查找  发布日期  为  2014-12-21  的数据
             */
            rf = new RowFilter(CompareOp.EQUAL , new SubstringComparator("_2014-12-21_"));
    
    
            //单值过滤器1完整匹配字节数组
            new SingleColumnValueFilter("base_info".getBytes(), "name".getBytes(), CompareOp.EQUAL, "zhangsan".getBytes());
            //单值过滤器2 匹配正则表达式
            ByteArrayComparable comparator = new RegexStringComparator("zhang.");
            new SingleColumnValueFilter("info".getBytes(), "NAME".getBytes(), CompareOp.EQUAL, comparator);
    
            //单值过滤器3匹配是否包含子串,大小写不敏感
            comparator = new SubstringComparator("wu");
            new SingleColumnValueFilter("info".getBytes(), "NAME".getBytes(), CompareOp.EQUAL, comparator);
    
            //键值对元数据过滤-----family过滤----字节数组完整匹配
            FamilyFilter ff = new FamilyFilter(
                    CompareOp.EQUAL , 
                    new BinaryComparator(Bytes.toBytes("base_info"))   //表中不存在inf列族，过滤结果为空
                    );
            //键值对元数据过滤-----family过滤----字节数组前缀匹配
            ff = new FamilyFilter(
                    CompareOp.EQUAL , 
                    new BinaryPrefixComparator(Bytes.toBytes("inf"))   //表中存在以inf打头的列族info，过滤结果为该列族所有行
                    );
    
           //键值对元数据过滤-----qualifier过滤----字节数组完整匹配
    
            filter = new QualifierFilter(
                    CompareOp.EQUAL , 
                    new BinaryComparator(Bytes.toBytes("na"))   //表中不存在na列，过滤结果为空
                    );
            filter = new QualifierFilter(
                    CompareOp.EQUAL , 
                    new BinaryPrefixComparator(Bytes.toBytes("na"))   //表中存在以na打头的列name，过滤结果为所有行的该列数据
                    );
    
            //基于列名(即Qualifier)前缀过滤数据的ColumnPrefixFilter
            filter = new ColumnPrefixFilter("na".getBytes());
    
            //基于列名(即Qualifier)多个前缀过滤数据的MultipleColumnPrefixFilter
            byte[][] prefixes = new byte[][] {Bytes.toBytes("na"), Bytes.toBytes("me")};
            filter = new MultipleColumnPrefixFilter(prefixes);
    
            //为查询设置过滤条件
            scan.setFilter(filter);
    
    
    
            scan.addFamily(Bytes.toBytes("base_info"));
            //一行
    //      Result result = table.get(get);
            //多行的数据
            ResultScanner scanner = table.getScanner(scan);
            for(Result r : scanner){
                /**
                for(KeyValue kv : r.list()){
                    String family = new String(kv.getFamily());
                    System.out.println(family);
                    String qualifier = new String(kv.getQualifier());
                    System.out.println(qualifier);
                    System.out.println(new String(kv.getValue()));
                }
                */
                //直接从result中取到某个特定的value
                byte[] value = r.getValue(Bytes.toBytes("base_info"), Bytes.toBytes("name"));
                System.out.println(new String(value));
            }
            table.close();
        }